डेटा फ्रेम के बारे में
सिलेबस के दूसरे हिस्सों में हमने अलग-अलग विशेषताओं वाले कई डेटा टाइप देखे हैं।
- एटॉमिक वेक्टर एक-आयामी होते हैं और टाइप में एक ही तरह के होते हैं।
-
लिस्ट एक-आयामी होती हैं और इनके एलिमेंट अलग-अलग टाइप के हो सकते हैं।
-
मैट्रिक्स और ऐरे बहु-आयामी और एक ही तरह के होते हैं।
इस कॉन्सेप्ट में हम बहु-आयामी और अलग-अलग तरह के डेटा को संग्रहीत करने के तरीके देखेंगे।
व्यवहार में, वास्तविक दुनिया का अधिकतर डेटा ऐसा ही होता है, इसलिए अब हम इस बात के केंद्र तक पहुँच रहे हैं कि R का इस्तेमाल (अधिकतर) कैसे होता है।
डेटा फ्रेम के प्रकार
दशकों में R ने टेबल के रूप वाले डेटा को संभालने के लिए कई डेटा टाइप जोड़े हैं।
यह सिलेबस मुख्य रूप से tibble पर केंद्रित रहेगा, लेकिन कुछ विकल्पों के बारे में जानना भी काम का है।
data.table
tibble (नीचे इनका उल्लेख है) और data.table, दोनों ही Base R के पारंपरिक data.frame को बेहतर बनाने की प्रतिष्ठित कोशिशें हैं।
इस बात पर बहस होना तय है कि इनमें से कौन "बेहतर" है।
शायद नीचे दी गई बातों पर कुछ हद तक सहमति है (भले ही इन्हें बहुत सरल कहकर आलोचना की जाए)।
-
tibble मुख्य रूप से इस्तेमाल में आसानी और Tidyverse इकोसिस्टम के साथ एकीकरण के लिए बनाया गया है।
-
data.table मुख्य रूप से शक्ति और स्केलेबिलिटी के लिए बनाया गया है, खासकर जब बहुत बड़े डेटासेट पर काम किया जाता है।
किसी भी हालत में, data.table Exercism में उपलब्ध नहीं है, इसलिए इसका उल्लेख यहाँ सिर्फ पूर्णता के लिए किया गया है।
data.frame
Base R में, एक data.frame बराबर लंबाई वाले vectors की एक list होती है।
इसे डेटा की एक आयताकार टेबल की तरह सोचा जा सकता है, जिसमें हर कॉलम एक ही तरह का होता है, लेकिन हर रो में (और आमतौर पर होता भी है) अलग-अलग टाइप का डेटा हो सकता है।
इसे समझाने के लिए एक उदाहरण:
# create the column vectors
languages <- c("Fortran", "R", "Python", "Julia")
created <- c(1957, 1993, 1991, 2012)
has.syllabus <- c(FALSE, TRUE, TRUE, TRUE)
# join columns to create the dataframe
df <- data.frame(languages, created, has.syllabus)
df
#> languages created has.syllabus
#> 1 Fortran 1957 FALSE
#> 2 R 1993 TRUE
#> 3 Python 1991 TRUE
#> 4 Julia 2012 TRUE
# look at the structure
str(df)
#> 'data.frame': 4 obs. of 3 variables:
#> $ languages : chr "Fortran" "R" "Python" "Julia"
#> $ created : num 1957 1993 1991 2012
#> $ has.syllabus: logi FALSE TRUE TRUE TRUE
यहाँ हमारे पास अक्षर स्ट्रिंग का एक कॉलम, संख्याओं का एक कॉलम और बूलियन का एक कॉलम है।
जब इसे बड़े पैमाने पर देखा जाए, तो यह वास्तविक दुनिया के बहुत सारे डेटा-संग्रहों को दिखाने का एक समझने में आसान तरीका है।
tibble
data.frame का डिज़ाइन पुराना है।
कई दशकों के अनुभव और R के इस्तेमाल के बदलते तरीकों ने एक नए डिज़ाइन की राह दिखाई, जिससे Tidyverse में एक आधुनिक विकल्प बना: tibble।
Base R की तुलना में tibble में ये बातें हैं:
- अलग डिफॉल्ट, ताकि आम समस्याएँ कम हों।
- इनपुट के समय डेटा टाइप को ज़बरदस्ती बदलने की कम कोशिश।
- अधिक और स्पष्ट एरर संदेश।
- अलग, और आमतौर पर बेहतर, दिखाने के तरीके।
संक्षेप में, एक tibble का उद्देश्य है "कम करना और ज़्यादा शिकायत करना", जिसे "आलसी और रूखा" भी कहा जाता है।
ये टाइप आमतौर पर एक-दूसरे की जगह इस्तेमाल हो सकते हैं: कोई भी फंक्शन जो data.frame लेता है, वह tibble भी ले लेगा, और इसका उलटा भी।
इन टाइपों के बीच बदलाव आसान है, as_tibble(df) और as.data.frame(tbl) की मदद से।
नए काम के लिए, tibble इस्तेमाल करना शायद आपको ज़्यादा मज़बूत कोड बनाने में मदद करेगा।
लेकिन R की दुनिया में पुराना कोड और पुराना डेटा बहुत भरा पड़ा है, इसलिए data.frame लंबे समय तक आम बना रहने की संभावना है।
# column vectors are same as for data.frame
library(tibble)
tbl <- tibble(languages, created, has.syllabus)
tbl
# A tibble: 4 × 3
#> languages created has.syllabus
#> <chr> <dbl> <lgl>
#> 1 Fortran 1957 FALSE
#> 2 R 1993 TRUE
#> 3 Python 1991 TRUE
#> 4 Julia 2012 TRUE
str(tbl)
#> tibble [4 × 3] (S3: tbl_df/tbl/data.frame)
#> $ languages : chr [1:4] "Fortran" "R" "Python" "Julia"
#> $ created : num [1:4] 1957 1993 1991 2012
#> $ has.syllabus: logi [1:4] FALSE TRUE TRUE TRUE
डिफॉल्ट प्रिंट फॉर्मेट पर ध्यान दीजिए: आयामों वाली कमेंट लाइन अपने आप प्रिंट होती है, और कॉलम के टाइप भी दिखाए जाते हैं।
tibble के साथ काम करना
tibble, Tidyverse का मुख्य हिस्सा हैं, इसलिए इन्हें library(tibble) या library(tidyverse) से जोड़ लीजिए।
डॉक्युमेंटेशन काफी विस्तृत है, Tidyverse की शैली में:
tibble बनाना
सबसे आसान तरीका यह है कि हम कॉलम वेक्टर जोड़ने के लिए tibble() फंक्शन इस्तेमाल करें, ठीक वैसे ही जैसे data.frame() के लिए करते हैं।
इसका एक उदाहरण पिछले भाग में दिखाया गया था।
अगर वैल्यू रो के हिसाब से डालना ज़्यादा सुविधाजनक लगे, तो उसके लिए tribble() फंक्शन है।
tbl_r <- tribble(
# column names marked with tilde prefix
~languages, ~created, ~has.syllabus,
"Fortran", 1957, FALSE,
"R", 1993, TRUE,
"Python", 1991, TRUE,
"Julia", 2012, TRUE
)
tbl_r
# A tibble: 4 × 3
#> languages created has.syllabus
#> <chr> <dbl> <lgl>
#> 1 Fortran 1957 FALSE
#> 2 R 1993 TRUE
#> 3 Python 1991 TRUE
#> 4 Julia 2012 TRUE
व्यवहार में, tibble बनाने के दर्जनों तरीके हैं, क्योंकि Tidyverse के कई अलग-अलग फंक्शन इन्हें डिफॉल्ट आउटपुट के रूप में देते हैं।
हम इस पर आगे किसी कॉन्सेप्ट में फिर आएँगे।
tibble में बदलाव करना
फंक्शनल प्रोग्रामिंग कॉन्सेप्ट में purrr लाइब्रेरी की चर्चा हुई थी, जो वेक्टर और लिस्ट (एक-आयामी डेटा संरचनाओं) में बदलाव करने के लिए है।
डेटा फ्रेम के लिए (चाहे पुराने हों या tibble), इस्तेमाल करने वाली लाइब्रेरी dplyr है।
हमने dplyr से पहले स्विच कॉन्सेप्ट में परिचय कराया था।
वहाँ इसके कुछ ही उपयोगी फंक्शन इस्तेमाल हुए थे, लेकिन अब हम इस बड़ी लाइब्रेरी के बाकी हिस्से को देखना शुरू कर सकते हैं।
सबसेट बनाना
डेटा फ्रेम, tibble समेत, कॉलम वेक्टर की लिस्ट की तरह माने जा सकते हैं, इसलिए लिस्ट इंडेक्सिंग से कोई चुना हुआ कॉलम मिल जाता है।
tbl
# A tibble: 4 × 3
#> languages created has.syllabus
#> <chr> <dbl> <lgl>
#> 1 Fortran 1957 FALSE
#> 2 R 1993 TRUE
#> 3 Python 1991 TRUE
#> 4 Julia 2012 TRUE
tbl$created
#> [1] 1957 1993 1991 2012
डेटा फ्रेम को मैट्रिक्स की तरह इंडेक्स भी किया जा सकता है।
tbl[c(2, 4), 1:2]
# A tibble: 2 × 2
#> languages created
#> <chr> <dbl>
#> 1 R 1993
#> 2 Julia 2012
Tidyverse इकोसिस्टम वाले आधुनिक R में, dplyr के फंक्शन आमतौर पर ज़्यादा लचीले और सुविधाजनक हैं, और इस कॉन्सेप्ट के बाकी हिस्से में हम इन्हीं पर ध्यान देंगे।
कॉलम के हिसाब से काम
pull() से एक अकेला कॉलम पाइए, उसके नाम या क्रम वाले नंबर से (दाएँ से बाएँ गिनने के लिए ऋणात्मक संख्याएँ दीजिए)।
tbl |> pull(created)
#> [1] 1957 1993 1991 2012
इसका नतीजा tbl$created जैसा ही है, बस यहाँ पाइपलाइन के साथ चलने वाला फंक्शन इस्तेमाल हुआ है।
कई कॉलम पाने के लिए सही फंक्शन select() है, जो बहुत बहुमुखी है।
कॉलम पाइए (या हटाइए) उनके नाम या टाइप के गुणों के आधार पर।
# Range with position and/or name
tbl |> select(1:created)
# A tibble: 4 × 2
#> languages created
#> <chr> <dbl>
#> 1 Fortran 1957
#> 2 R 1993
#> 3 Python 1991
#> 4 Julia 2012
# Exclude a column
tbl |> select(!created)
# A tibble: 4 × 2
#> languages has.syllabus
#> <chr> <lgl>
#> 1 Fortran FALSE
#> 2 R TRUE
#> 3 Python TRUE
#> 4 Julia TRUE
# Use type of column
tbl |> select(where(is.numeric))
# A tibble: 4 × 1
#> created
#> <dbl>
#> 1 1957
#> 2 1993
#> 3 1991
#> 4 2012
कई शर्तें भी दी जा सकती हैं, बूलियन ऑपरेटर &, | और ! (और, या, नहीं) इस्तेमाल करके।
जो कॉलम नाम R में मान्य आइडेंटिफायर हैं, उन्हें select() के अंदर कोट्स की ज़रूरत नहीं होती।
अमान्य नामों (जैसे जिनमें स्पेस हों) को बैकटिक के अंदर रखा जा सकता है, हालाँकि उनका नाम बदल देना ज़्यादा अच्छा हो सकता है।
select() फंक्शन कॉलम नाम चुनने के लिए कई हेल्पर फंक्शन के साथ काम कर सकता है: starts_with, contains, num_range और कई और।
matches पूरा रेगुलर एक्सप्रेशन मैच करने देता है।
पूरी जानकारी के लिए डॉक्युमेंटेशन देखिए।
भाषाओं वाले हमारे इस छोटे उदाहरण डेटा फ्रेम के साथ इतनी शक्ति काफी बेमानी लगती है।
अच्छी बात है कि dplyr में starwars tibble भी शामिल है, जो हमें अभ्यास के लिए कुछ बड़ा देता है।
# limit display to top 3 rows of non-list columns
starwars |>
select(!where(is.list)) |>
head(3)
# A tibble: 3 × 11
#> name height mass hair_color skin_color eye_color birth_year sex gender homeworld species
#> <chr> <int> <dbl> <chr> <chr> <chr> <dbl> <chr> <chr> <chr> <chr>
#> 1 Luke Skywalker 172 77 blond fair blue 19 male masculine Tatooine Human
#> 2 C-3PO 167 75 NA gold yellow 112 none masculine Tatooine Droid
#> 3 R2-D2 96 32 NA white, blue red 33 none masculine Naboo Droid
# pick a subset of columns
starwars |>
select(name | ends_with("color")) |>
head(5)
# A tibble: 5 × 4
#> name hair_color skin_color eye_color
#> <chr> <chr> <chr> <chr>
#> 1 Luke Skywalker blond fair blue
#> 2 C-3PO NA gold yellow
#> 3 R2-D2 NA white, blue red
#> 4 Darth Vader none white yellow
#> 5 Leia Organa brown light brown
रो के हिसाब से काम
साफ है कि dplyr कॉलम को नाम से चुनने के शक्तिशाली तरीके देता है।
क्या हम रो के नामों के साथ भी ऐसा कुछ कर सकते हैं?
नहीं!
पुराने R डेटा फ्रेम में रो के नाम हो सकते हैं, लेकिन (बग और परफॉर्मेंस की समस्याओं के लंबे इतिहास के बाद) tibbles में रो के नाम अनुमत नहीं हैं।
अगर आपको नाम चाहिए, तो उन्हें एक <chr> कॉलम में रखिए (आमतौर पर कॉलम 1), और उसे किसी भी दूसरे कॉलम की तरह इस्तेमाल कीजिए।
as_tibble() जैसे इम्पोर्ट फंक्शन, नाम वाली रो के साथ डेटा इम्पोर्ट करते समय यह कॉलम अपने आप बना देते हैं।
अगर रो के नाम न होने की यह पाबंदी अजीब-सी रोक-टोक लगती है, तो याद रखिए कि ज़्यादातर बड़े डेटाबेस सिस्टम भी टेबल को इसी तरह संभालते हैं: Oracle, SQL Server, PostgreSQL, MySQL...
किसी शर्त से मेल खाती रो filter() से पाइए, या filter_out() से उन्हें हटा दीजिए।
starwars |>
select(name:mass) |>
filter(between(height, 150, 165) & !is.na(mass))
# A tibble: 4 × 3
#> name height mass
#> <chr> <int> <dbl>
#> 1 Leia Organa 150 49
#> 2 Beru Whitesun Lars 165 75
#> 3 Nien Nunb 160 68
#> 4 Ben Quadinaros 163 65
फिल्टर की शर्तें मनमाने ढंग से जटिल हो सकती हैं, लेकिन हमेशा रो की सामग्री पर आधारित होती हैं।
अगर रो के नंबर पता हों, तो हम slice() के कई फंक्शन इस्तेमाल कर सकते हैं।
starwars |>
select(name | homeworld) |>
slice(20:25)
# A tibble: 6 × 2
#> name homeworld
#> <chr> <chr>
#> 1 Palpatine Naboo
#> 2 Boba Fett Kamino
#> 3 IG-88 NA
#> 4 Bossk Trandosha
#> 5 Lando Calrissian Socorro
#> 6 Lobot Bespin
# random sample of rows
starwars |>
select(name | homeworld) |>
slice_sample(n = 4)
# A tibble: 4 × 2
#> name homeworld
#> <chr> <chr>
#> 1 Shaak Ti Shili
#> 2 Luminara Unduli Mirial
#> 3 Grievous Kalee
#> 4 Palpatine Naboo
डुप्लिकेट रो हटाने के लिए distinct() इस्तेमाल कीजिए।
tibble को बदलना
पहली बात ध्यान रखिए: कॉपी-ऑन-मॉडिफाई का डिफॉल्ट इसका मतलब है कि मूल tibble आमतौर पर बदला नहीं रहता।
ज़्यादातर बदलाव कॉलम के हिसाब से लागू होते हैं।
कॉलम के नाम rename(newname = oldname) से बदले जा सकते हैं, या किसी फंक्शन को लागू करने के लिए rename_with() से।
इसका एक आम इस्तेमाल यह होगा कि इम्पोर्ट किए गए नामों को साफ किया जाए, ताकि R में उन पर काम करना आसान हो। इसके लिए खाली जगह हटाई जाती है और जुड़े हुए नामों का एक जैसा फॉर्मेट तय किया जाता है।
rename() के अंदर के सिंटैक्स पर ध्यान दीजिए।
कॉलम oldname की सामग्री को newname नाम से जोड़ा जाता है, इसीलिए यह क्रम है।
कॉलम का क्रम relocate() से बदला जा सकता है।
बताए गए कॉलम डिफॉल्ट रूप से सबसे बाईं जगह पर चले जाते हैं, लेकिन बारीक जगह तय करने के लिए .before या .after आर्गुमेंट इस्तेमाल किया जा सकता है।
sw <- starwars |> select(name:species) |> slice(1:4)
sw
# A tibble: 4 × 11
#> name height mass hair_color skin_color eye_color birth_year sex gender homeworld species
#> <chr> <int> <dbl> <chr> <chr> <chr> <dbl> <chr> <chr> <chr> <chr>
#> 1 Luke Skywalker 172 77 blond fair blue 19 male masculine Tatooine Human
#> 2 C-3PO 167 75 NA gold yellow 112 none masculine Tatooine Droid
#> 3 R2-D2 96 32 NA white, blue red 33 none masculine Naboo Droid
#> 4 Darth Vader 202 136 none white yellow 41.9 male masculine Tatooine Human
sw |> relocate(c(species, homeworld), .after = name)
# A tibble: 4 × 11
#> name species homeworld height mass hair_color skin_color eye_color birth_year sex gender
#> <chr> <chr> <chr> <int> <dbl> <chr> <chr> <chr> <dbl> <chr> <chr>
#> 1 Luke Skywalker Human Tatooine 172 77 blond fair blue 19 male masculine
#> 2 C-3PO Droid Tatooine 167 75 NA gold yellow 112 none masculine
#> 3 R2-D2 Droid Naboo 96 32 NA white, blue red 33 none masculine
#> 4 Darth Vader Human Tatooine 202 136 none white yellow 41.9 male masculine
बड़े बदलावों के लिए, mutate() आपको ये सब करने देता है:
- ऐसे नए कॉलम बनाना जो मौजूदा कॉलम पर आधारित हों।
- किसी मौजूदा कॉलम को बदलना, उसी नाम से नया कॉलम बनाकर।
- किसी कॉलम को हटाना, उसकी वैल्यू
NULL करके।
साफ है कि mutate() शक्तिशाली है, कभी-कभी उलझाने वाला भी, और कॉपी-ऑन-मॉडिफाई के लिए हमें बहुत आभारी होने की एक वजह भी।
Star Wars के पात्रों के बॉडी मास इंडेक्स की परवाह करने की कोई खास वजह नहीं है, लेकिन फिर भी:
starwars |>
select(c(name, species, height, mass)) |>
mutate(BMI = mass / (height / 100)^2) |>
head(4)
# A tibble: 4 × 5
#> name species height mass BMI
#> <chr> <chr> <int> <dbl> <dbl>
#> 1 Luke Skywalker Human 172 77 26.0
#> 2 C-3PO Droid 167 75 26.9
#> 3 R2-D2 Droid 96 32 34.7
#> 4 Darth Vader Human 202 136 33.3
जब आप mutate() जैसे फंक्शन से कॉलम के किसी सबसेट पर काम करना चाहें, तो ऊपर के उदाहरण में दिया गया select() |> mutate() क्रम एक तरीका है।
नतीजे में सिर्फ चुने हुए कॉलम ही होंगे।
या फिर, mutate() कॉल के अंदर pick() इस्तेमाल करना सुविधाजनक हो सकता है:
starwars |> mutate(pick(c(name, species, height, mass)), BMI = mass / (height / 100)^2) |> head(4)
When you want to operate on a subset of the columns with functions such as `mutate()`, the `select() |> mutate()` sequence in the above example is one option.
Only the selected columns will be in the result.
Alternatively, it can be convenient to use `pick()` _within_ the `mutate()` call:
```R
starwars |> mutate(pick(c(name, species, height, mass)), BMI = mass / (height / 100)^2) |> head(4)
# A tibble: 4 × 15
#> name height mass hair_color skin_color eye_color birth_year sex gender homeworld species films vehicles
#> <chr> <int> <dbl> <chr> <chr> <chr> <dbl> <chr> <chr> <chr> <chr> <lis> <list>
#> 1 Luke Skywal… 172 77 blond fair blue 19 male mascu… Tatooine Human <chr> <chr>
#> 2 C-3PO 167 75 NA gold yellow 112 none mascu… Tatooine Droid <chr> <chr>
#> 3 R2-D2 96 32 NA white, bl… red 33 none mascu… Naboo Droid <chr> <chr>
#> 4 Darth Vader 202 136 none white yellow 41.9 male mascu… Tatooine Human <chr> <chr>
# ℹ 2 more variables: starships <list>, BMI <dbl>
म्यूटेशन में सिर्फ pick किए गए कॉलम इस्तेमाल होते हैं, लेकिन सारे कॉलम लौटाए जाते हैं।
अकेले tibble को बदलने में रो के हिसाब से काम कम आम है (कई tibble जोड़ने की बात आगे किसी कॉन्सेप्ट में होगी)।
एक अपवाद: arrange() रो को एक या ज़्यादा कॉलम की वैल्यू के हिसाब से क्रम में लगाता है।
tbl
# A tibble: 4 × 3
#> languages created has.syllabus
#> <chr> <dbl> <lgl>
#> 1 Fortran 1957 FALSE
#> 2 R 1993 TRUE
#> 3 Python 1991 TRUE
#> 4 Julia 2012 TRUE
tbl |> arrange(languages)
# A tibble: 4 × 3
#> languages created has.syllabus
#> <chr> <dbl> <lgl>
#> 1 Fortran 1957 FALSE
#> 2 Julia 2012 TRUE
#> 3 Python 1991 TRUE
#> 4 R 1993 TRUE
सारांश
डेटा फ्रेम, चाहे पुराने हों या tibble, आधुनिक R के आम इस्तेमाल के केंद्र में हैं।
Tidyverse के ज़्यादातर फंक्शन (सिर्फ dplyr ही नहीं) tibble को इनपुट की तरह लेते हैं और/या आउटपुट की तरह बनाते हैं।
इस कॉन्सेप्ट में बस एक छोटा-सा परिचय दिया गया है, जो संभावनाओं की सतह को भी मुश्किल से छूता है।
आगे के कॉन्सेप्ट में डेटा फ्रेम के कई और पहलुओं पर चर्चा होगी (Exercism की तकनीकी सीमाओं के भीतर)।
1 अभ्यास
डेटा फ्रेम सीखिए