मैं डेटा फ़्रेमों की एक सूची कैसे बनाऊँ?

Question

मैं डेटा फ़्रेमों की एक सूची कैसे बनाऊं और मैं उन डेटा फ़्रेमों में से प्रत्येक को सूची से कैसे एक्सेस कर सकता हूं?

उदाहरण के लिए, मैं इन डेटा फ़्रेमों को एक सूची में कैसे रख सकता हूं?

d1 <- data.frame(y1 = c(1, 2, 3),
                 y2 = c(4, 5, 6))
d2 <- data.frame(y1 = c(3, 2, 1),
                 y2 = c(6, 5, 4))

Comments

यह एक जोड़े के जवाब में है, लेकिन यह यहां एक दृश्यमान टिप्पणी के लायक है: अंदर =नहीं का उपयोग करें । का उपयोग करके आपके द्वारा बनाए गए और अपने वैश्विक वातावरण और अपने डेटा फ्रेम में क्या आप इसे होना चाहते हैं नहीं है। <-data.frame()<-y1y2

— ग्रेगर थॉमस

बिना किसी रिक्त स्थान के कोड की उस गड़बड़ी को देखें और <-data.frame () के अंदर हैं। मैं क्या नवाब था।

— बेन

अब और नहीं। मैंने कोड फ़ॉर्मेटिंग को ठीक करने के लिए आपके प्रश्न को संपादित किया है। यदि आप उदासीन महसूस करते हैं तो वापस लौटने के लिए स्वतंत्र महसूस करें।

— क्लॉस विलके

Answer 1

यह आपके प्रश्न से संबंधित नहीं है, लेकिन आप उपयोग करना चाहते हैं =और <-फ़ंक्शन कॉल में नहीं। यदि आप उपयोग करते हैं <-, तो आप चर बना रहे हैं y1और y2जिस भी वातावरण में आप काम कर रहे हैं:

d1 <- data.frame(y1 <- c(1, 2, 3), y2 <- c(4, 5, 6))
y1
# [1] 1 2 3
y2
# [1] 4 5 6

इससे डेटा फ़्रेम में स्तंभ नाम बनाने का वांछित वांछित प्रभाव नहीं होगा:

d1
#   y1....c.1..2..3. y2....c.4..5..6.
# 1                1                4
# 2                2                5
# 3                3                6

=ऑपरेटर, दूसरे हाथ पर, के लिए तर्क के साथ अपने वैक्टर संबद्ध कर दिया जाएगा data.frame।

आपके प्रश्न के लिए, डेटा फ़्रेम की सूची बनाना आसान है:

d1 <- data.frame(y1 = c(1, 2, 3), y2 = c(4, 5, 6))
d2 <- data.frame(y1 = c(3, 2, 1), y2 = c(6, 5, 4))
my.list <- list(d1, d2)

आप किसी अन्य सूची तत्व को एक्सेस करने की तरह ही डेटा फ़्रेमों का उपयोग करेंगे:

my.list[[1]]
#   y1 y2
# 1  1  4
# 2  2  5
# 3  3  6

Answer 2

अन्य उत्तर आपको बताएंगे कि कैसे आप जब data.frames की एक सूची बनाने के लिए पहले से ही है data.frames, जैसे, का एक समूह d1, d2, .... क्रमिक रूप से नामित डेटा फ्रेम हो रही है एक समस्या है, और उन्हें एक सूची में डालने के एक है अच्छा तय है, लेकिन सबसे अच्छी प्रैक्टिस डेटा का एक गुच्छा होने से बचने के लिए है। पहली जगह में एक सूची में नहीं ।

अन्य उत्तर तत्वों को सूचीबद्ध करने, उन्हें एक्सेस करने आदि के लिए डेटा फ्रेम्स को कैसे असाइन करें, इसके बारे में विस्तार से जानकारी देते हैं। हम इसे यहां भी थोड़ा कवर करेंगे, लेकिन मुख्य बिंदु यह है कि तब तक प्रतीक्षा न करें जब तक आपके पास एक गुच्छा न हो data.framesउन्हें सूची में जोड़ने के लिए। सूची से शुरू करें।

इस उत्तर के बाकी हिस्से कुछ सामान्य मामलों को कवर करेंगे, जहां आपको अनुक्रमिक चर बनाने के लिए लुभाया जा सकता है, और आपको यह दिखाया जाएगा कि सूची में सीधे कैसे जाएं। यदि आप आर में सूचियों के लिए नए हैं, तो आप को भी पढ़ा चाहते हो सकता है बीच क्या अंतर है [[और [एक सूची के तत्वों तक पहुँचने में? ।

---

शुरू से सूची

कभी भी d1 d2 d3, ..., dnपहले स्थान पर न बनाएं । तत्वों के dसाथ एक सूची बनाएं n।

डेटा फ़्रेम की सूची में कई फ़ाइलों को पढ़ना

फ़ाइलों में पढ़ते समय यह बहुत आसानी से किया जाता है। हो सकता है कि आपको data1.csv, data2.csv, ...निर्देशिका में फ़ाइलें मिली हों । आपका लक्ष्य data.frames की एक सूची है जिसे कहा जाता है mydata। पहली चीज जो आपको चाहिए वह सभी फ़ाइल नामों के साथ एक वेक्टर है। आप इसे पेस्ट (जैसे my_files = paste0("data", 1:5, ".csv")) के साथ बना सकते हैं , लेकिन list.filesसभी उपयुक्त फ़ाइलों को हथियाने के लिए उपयोग करना आसान है my_files <- list.files(pattern = "\\.csv$"):। आप फ़ाइलों से मिलान करने के लिए नियमित अभिव्यक्तियों का उपयोग कर सकते हैं, अन्य प्रश्नों में नियमित अभिव्यक्तियों के बारे में अधिक पढ़ सकते हैं यदि आपको वहां सहायता की आवश्यकता है। इस तरह आप सभी CSV फ़ाइलों को हड़प सकते हैं, भले ही वे एक अच्छी नामकरण योजना का पालन न करें। या आप एक कट्टर रेगेक्स पैटर्न का उपयोग कर सकते हैं यदि आपको उनमें से कुछ सीएसवी फ़ाइलों को निकालने की आवश्यकता है।

इस बिंदु पर, अधिकांश आर शुरुआती एक forलूप का उपयोग करेंगे , और इसके साथ कुछ भी गलत नहीं है, यह ठीक काम करता है।

my_data <- list()
for (i in seq_along(my_files)) {
    my_data[[i]] <- read.csv(file = my_files[i])
}

ऐसा करने के लिए एक अधिक आर-जैसे तरीका है lapply, जो कि ऊपर के लिए एक शॉर्टकट है

my_data <- lapply(my_files, read.csv)

बेशक, read.csvउपयुक्त के लिए अन्य डेटा आयात समारोह स्थानापन्न । readr::read_csvया data.table::freadतेजी से हो जाएगा, या आपको एक अलग फ़ाइल प्रकार के लिए एक अलग फ़ंक्शन की आवश्यकता हो सकती है।

किसी भी तरह से, फाइलों से मिलान करने के लिए सूची तत्वों को नाम देना आसान है

names(my_data) <- gsub("\\.csv$", "", my_files)
# or, if you prefer the consistent syntax of stringr
names(my_data) <- stringr::str_replace(my_files, pattern = ".csv", replacement = "")

डेटा फ़्रेम को डेटा फ़्रेम की सूची में विभाजित करना

यह सुपर-आसान है, आधार फ़ंक्शन split()यह आपके लिए करता है। आप डेटा के एक कॉलम (या कॉलम), या किसी और चीज़ से, जो आप चाहते हैं, द्वारा विभाजित कर सकते हैं

mt_list = split(mtcars, f = mtcars$cyl)
# This gives a list of three data frames, one for each value of cyl

क्रॉस-वेलिडेशन के लिए डेटा फ़्रेम को टुकड़ों में तोड़ने का यह भी एक अच्छा तरीका है। शायद आप mtcarsप्रशिक्षण, परीक्षण और सत्यापन टुकड़ों में विभाजित करना चाहते हैं ।

groups = sample(c("train", "test", "validate"),
                size = nrow(mtcars), replace = TRUE)
mt_split = split(mtcars, f = groups)
# and mt_split has appropriate names already!

डेटा फ़्रेम की एक सूची का अनुकरण करना

शायद आप डेटा का अनुकरण कर रहे हैं, कुछ इस तरह से:

my_sim_data = data.frame(x = rnorm(50), y = rnorm(50))

लेकिन केवल एक अनुकरण कौन करता है? आप इसे 100 बार, 1000 बार, अधिक करना चाहते हैं! लेकिन आप अपने कार्यक्षेत्र में 10,000 डेटा फ्रेम नहीं चाहते हैं। उपयोग करें replicateऔर उन्हें एक सूची में रखें:

sim_list = replicate(n = 10,
                     expr = {data.frame(x = rnorm(50), y = rnorm(50))},
                     simplify = F)

इस मामले में, विशेष रूप से, आपको यह भी विचार करना चाहिए कि क्या आपको वास्तव में अलग-अलग डेटा फ़्रेम की आवश्यकता है, या "समूह" कॉलम के साथ एकल डेटा फ़्रेम भी काम करेगा? डेटा समूह में "समूह द्वारा" चीजों का उपयोग करना data.tableया करना dplyrकाफी आसान है।

मैंने अपना डेटा किसी सूची में नहीं डाला :( मैं अगली बार आऊंगा, लेकिन अब मैं क्या कर सकता हूं?

यदि वे एक विषम वर्गीकरण (जो असामान्य है), आप बस उन्हें असाइन कर सकते हैं:

mylist <- list()
mylist[[1]] <- mtcars
mylist[[2]] <- data.frame(a = rnorm(50), b = runif(50))
...

आप, एक पैटर्न में नामित किया गया डेटा फ्रेम है, तो जैसे, df1, df2, df3, और आप उन्हें एक सूची में चाहते हैं, आप कर सकते हैं getउन्हें अगर आप एक नियमित अभिव्यक्ति नाम से मेल करने लिख सकते हैं। कुछ इस तरह

df_list = mget(ls(pattern = "df[0-9]"))
# this would match any object with "df" followed by a digit in its name
# you can test what objects will be got by just running the
ls(pattern = "df[0-9]")
# part and adjusting the pattern until it gets the right objects.

आमतौर पर, mgetकई वस्तुओं को प्राप्त करने और उन्हें एक नामित सूची में वापस करने के लिए उपयोग किया जाता है। इसके समकक्ष getका उपयोग किसी एक वस्तु को प्राप्त करने और उसे वापस करने के लिए किया जाता है (सूची में नहीं)।

किसी एकल डेटा फ़्रेम में डेटा फ़्रेम की सूची को संयोजित करना

एक सामान्य कार्य डेटा फ़्रेम की सूची को एक बड़े डेटा फ़्रेम में संयोजित कर रहा है। यदि आप उन्हें एक-दूसरे के शीर्ष पर रखना चाहते हैं, तो आप rbindउनमें से एक जोड़ी के लिए उपयोग करेंगे, लेकिन डेटा फ़्रेमों की एक सूची के लिए यहां तीन अच्छे विकल्प हैं:

# base option - slower but not extra dependencies
big_data = do.call(what = rbind, args = df_list)

# data table and dplyr have nice functions for this that
#  - are much faster
#  - add id columns to identify the source
#  - fill in missing values if some data frames have more columns than others
# see their help pages for details
big_data = data.table::rbindlist(df_list)
big_data = dplyr::bind_rows(df_list)

(इसी तरह से कॉलम के लिए उपयोग cbindकर dplyr::bind_colsरहे हैं।)

डेटा फ़्रेम की एक सूची को मर्ज (ज्वाइन) करने के लिए, आप इन उत्तरों को देख सकते हैं । अक्सर, विचार का उपयोग करने के लिए है Reduceके साथ mergeउन्हें एक साथ पाने के लिए (या कुछ अन्य में शामिल होने के समारोह)।

डेटा को सूची में क्यों रखा जाए?

सूचियों में समान डेटा रखो क्योंकि आप प्रत्येक डेटा फ्रेम के लिए इसी तरह काम करने के लिए चाहते हैं, और कार्यों की तरह lapply, sapply do.call, पैकेज , और पुराने कार्यों यह आसान करने के लिए बनाते हैं। सूचियों के साथ आसानी से काम करने वाले लोगों के उदाहरण SO पर हैं।purrrplyr l*ply

यहां तक ​​कि अगर आप लूप के लिए नीच का उपयोग करते हैं, तो सूची के तत्वों पर लूप करना बहुत आसान है, क्योंकि इसके साथ चर नामों का निर्माण करना pasteऔर वस्तुओं को एक्सेस करना है get। डिबग करने के लिए आसान, भी।

के बारे में सोचो scalability । आप वास्तव में केवल तीन चर, उपयोग करने के लिए यह ठीक की जरूरत है d1, d2, d3। लेकिन तब अगर यह पता चला कि आपको वास्तव में 6 की आवश्यकता है, तो यह बहुत अधिक टाइपिंग है। और अगली बार, जब आप 10 या 20 की जरूरत है, तो आप पाएंगे अपने आप को कॉपी करने और कोड की लाइनों चिपकाने, हो सकता है खोजने का उपयोग कर / बदलने के लिए बदलने के d14लिए d15, और आप सोच रहे हैं कि यह कैसे प्रोग्रामिंग होना चाहिए नहीं है । यदि आप एक सूची का उपयोग करते हैं, तो 3 मामलों, 30 मामलों और 300 मामलों के बीच अंतर कोड की एक पंक्ति में होता है --- यदि आपके मामलों की संख्या का स्वचालित रूप से पता लगाया जाता है, तो कोई परिवर्तन नहीं होता है, उदाहरण के लिए, .csvआपके पास कितनी फाइलें हैं निर्देशिका।

यदि आप अपने डेटा फ़्रेम्स तक पहुँचने के लिए संख्यात्मक सूचकांकों के अलावा किसी अन्य चीज़ का उपयोग करना चाहते हैं, तो आप किसी सूची के तत्वों को नाम दे सकते हैं, (आप XOR विकल्प नहीं हैं)।

कुल मिलाकर, सूचियों का उपयोग करने से आप क्लीनर, आसान-से-पढ़ा जाने वाला कोड लिख पाएंगे, जिसके परिणामस्वरूप कम कीड़े और कम भ्रम होगा।

Comments

आप किस पुस्तक की अनुशंसा करते हैं जो सूचियों के साथ काम करती है?

— Derelict

मैं स्टैक ओवरफ्लो पर प्रश्न और उत्तर पढ़ने की सलाह देता हूं जो दोनों के साथ टैग किए गए हैं rऔर list।

— ग्रिगोर थॉमस

@Gregor मैं यह जोड़ना चाहूंगा कि हम सूची के तत्वों से बचने के लिए फाइलों का मिलान करने के लिए केवल my_data <- NULLmy_data <- list () ' के बजाय असाइन कर सकते हैं ! :)

— डैनियल

यह संभव है, लेकिन my_data <- list()यह स्पष्ट करता है कि आप एक सूची बना रहे हैं, जो अच्छी है! स्पष्ट कोड एक अच्छी बात है। मुझे my_data <- NULLइसके बजाय उपयोग करने का कोई फायदा नहीं दिख रहा है ।

— ग्रिगोर थॉमस

मैं सहमत हूं, आपने जो कहा, उसके बारे में, लेकिन जैसा मैंने कहा, ऐसा करने से आप फाइलों के नामकरण के चरण से बच सकते हैं। names(my_data) <- gsub("\\.csv$", "", my_files) ;) <br> लेकिन मैं आपकी सलाह का सम्मान करता हूं क्योंकि मैं उनसे नौसिखिया के रूप में बहुत कुछ सीख रहा हूं और मैं वास्तव में इसकी सराहना करता हूं :)

— डैनियल

Answer 3

आप प्रत्येक सूची तत्व में [और उसके साथ विशिष्ट कॉलम और मान भी एक्सेस कर सकते हैं [[। यहां कुछ उदाहरण दिए गए हैं। सबसे पहले, हम सूची में प्रत्येक डेटा फ्रेम के केवल पहले कॉलम को एक्सेस कर सकते हैं lapply(ldf, "[", 1), जहां 1कॉलम नंबर को दर्शाता है।

ldf <- list(d1 = d1, d2 = d2)  ## create a named list of your data frames
lapply(ldf, "[", 1)
# $d1
#   y1
# 1  1
# 2  2
# 3  3
#
# $d2
#   y1
# 1  3
# 2  2
# 3  1

इसी तरह, हम दूसरे कॉलम में पहले मान को एक्सेस कर सकते हैं

lapply(ldf, "[", 1, 2)
# $d1
# [1] 4
# 
# $d2
# [1] 6

फिर हम कॉलम मानों को सीधे वेक्टर के रूप में भी एक्सेस कर सकते हैं [[

lapply(ldf, "[[", 1)
# $d1
# [1] 1 2 3
#
# $d2
# [1] 3 2 1

Answer 4

यदि आपके पास क्रमिक रूप से नामित डेटा फ़्रेम की एक बड़ी संख्या है, तो आप इस तरह से डेटा फ़्रेम के वांछित सबसेट की एक सूची बना सकते हैं:

d1 <- data.frame(y1=c(1,2,3), y2=c(4,5,6))
d2 <- data.frame(y1=c(3,2,1), y2=c(6,5,4))
d3 <- data.frame(y1=c(6,5,4), y2=c(3,2,1))
d4 <- data.frame(y1=c(9,9,9), y2=c(8,8,8))

my.list <- list(d1, d2, d3, d4)
my.list

my.list2 <- lapply(paste('d', seq(2,4,1), sep=''), get)
my.list2

जहाँ my.list22, 3 और 4 के डेटा फ़्रेम वाली सूची देता है।

[[1]]
  y1 y2
1  3  6
2  2  5
3  1  4

[[2]]
  y1 y2
1  6  3
2  5  2
3  4  1

[[3]]
  y1 y2
1  9  8
2  9  8
3  9  8

हालाँकि, ध्यान दें कि उपरोक्त सूची में डेटा फ़्रेम का नाम नहीं है। यदि आप एक सूची बनाना चाहते हैं जिसमें डेटा फ़्रेम का सबसेट होता है और आप उनके नामों को संरक्षित करना चाहते हैं तो आप यह कोशिश कर सकते हैं:

list.function <-  function() { 

     d1 <- data.frame(y1=c(1,2,3), y2=c(4,5,6))
     d2 <- data.frame(y1=c(3,2,1), y2=c(6,5,4))
     d3 <- data.frame(y1=c(6,5,4), y2=c(3,2,1))
     d4 <- data.frame(y1=c(9,9,9), y2=c(8,8,8))

     sapply(paste('d', seq(2,4,1), sep=''), get, environment(), simplify = FALSE) 
} 

my.list3 <- list.function()
my.list3

कौन सा रिटर्न:

> my.list3
$d2
  y1 y2
1  3  6
2  2  5
3  1  4

$d3
  y1 y2
1  6  3
2  5  2
3  4  1

$d4
  y1 y2
1  9  8
2  9  8
3  9  8

> str(my.list3)
List of 3
 $ d2:'data.frame':     3 obs. of  2 variables:
  ..$ y1: num [1:3] 3 2 1
  ..$ y2: num [1:3] 6 5 4
 $ d3:'data.frame':     3 obs. of  2 variables:
  ..$ y1: num [1:3] 6 5 4
  ..$ y2: num [1:3] 3 2 1
 $ d4:'data.frame':     3 obs. of  2 variables:
  ..$ y1: num [1:3] 9 9 9
  ..$ y2: num [1:3] 8 8 8

> my.list3[[1]]
  y1 y2
1  3  6
2  2  5
3  1  4

> my.list3$d4
  y1 y2
1  9  8
2  9  8
3  9  8

Comments

इसके बजाय lapply(foo, get), बस का उपयोग करेंmget(foo)

— ग्रेगर थॉमस

Answer 5

दिए गए अनुसार आपके पास समान नामों के साथ "बड़ी" data.frames की संख्या है (यहाँ d # जहाँ # कुछ सकारात्मक पूर्णांक है), निम्नलिखित @ चिह्न-मिलर की विधि का एक मामूली सुधार है। यह अधिक terse है और data.frames की एक नामित सूची लौटाता है, जहाँ सूची में प्रत्येक नाम संबंधित मूल data.frame का नाम है।

कुंजी mgetएक साथ उपयोग कर रहा है ls। यदि प्रश्न में प्रदान किए गए डेटा फ़्रेम d1 और d2 पर्यावरण में नाम # d के साथ एकमात्र ऑब्जेक्ट थे, तो

my.list <- mget(ls(pattern="^d[0-9]+"))

जो लौटेगा

my.list
$d1
  y1 y2
1  1  4
2  2  5
3  3  6

$d2
  y1 y2
1  3  6
2  2  5
3  1  4

यह पद्धति पैटर्न तर्क का लाभ उठाती है ls, जो हमें पर्यावरण में वस्तुओं के नामों की बारीक पार्सिंग करने के लिए नियमित अभिव्यक्ति का उपयोग करने की अनुमति देती है। रेगेक्स "^d[0-9]+$"का एक विकल्प है "^d\\d+$"।

जैसा कि @gregor बताते हैं , यह आपके डेटा निर्माण प्रक्रिया को स्थापित करने के लिए एक बेहतर समग्र है ताकि डेटा.फ्रेम को प्रारंभ में नामित सूचियों में डाल दिया जाए।

डेटा

d1 <- data.frame(y1 = c(1,2,3),y2 = c(4,5,6))
d2 <- data.frame(y1 = c(3,2,1),y2 = c(6,5,4))

Answer 6

इसमें थोड़ी देर हो सकती है, लेकिन आपके उदाहरण पर वापस जाते हुए मैंने सोचा कि मैं उत्तर का विस्तार केवल एक बालक के रूप में करूंगा।

 D1 <- data.frame(Y1=c(1,2,3), Y2=c(4,5,6))
 D2 <- data.frame(Y1=c(3,2,1), Y2=c(6,5,4))
 D3 <- data.frame(Y1=c(6,5,4), Y2=c(3,2,1))
 D4 <- data.frame(Y1=c(9,9,9), Y2=c(8,8,8))

फिर आप आसानी से अपनी सूची बनाते हैं:

mylist <- list(D1,D2,D3,D4)

अब आपके पास एक सूची है लेकिन सूची को पुराने तरीके से एक्सेस करने के बजाय जैसे कि

mylist[[1]] # to access 'd1'

आप अपनी पसंद के डेटाफ्रेम प्राप्त करने और असाइन करने के लिए इस फ़ंक्शन का उपयोग कर सकते हैं।

GETDF_FROMLIST <- function(DF_LIST, ITEM_LOC){
   DF_SELECTED <- DF_LIST[[ITEM_LOC]]
   return(DF_SELECTED)
}

अब आप जो चाहते हैं उसे प्राप्त करें।

D1 <- GETDF_FROMLIST(mylist, 1)
D2 <- GETDF_FROMLIST(mylist, 2)
D3 <- GETDF_FROMLIST(mylist, 3)
D4 <- GETDF_FROMLIST(mylist, 4)

आशा है कि अतिरिक्त बिट मदद करता है।

चीयर्स!

Comments

हां मुझे पता है लेकिन किसी कारण से जब मैंने नकल की और चिपकाया, तो सब कुछ कैप गया। :( किसी भी घटना में निचले मामले में कोड काम करता है।

— ML_for_now

क्यों आप पसंद करेंगे मैं उत्सुक हूँ GETDF_FROMLIST(mylist, 1)करने के लिए mylist[[1]]? यदि आप फ़ंक्शन सिंटैक्स पसंद करते हैं, तो आप "[["(mylist, 1)कस्टम फ़ंक्शन को परिभाषित किए बिना भी कर सकते हैं ।

— ग्रिगोर थॉमस

आप अपनी फ़ंक्शन परिभाषा को भी सरल बना सकते हैं, फ़ंक्शन का पूरा शरीर बस हो सकता है return(DF_LIST[[ITEM_LOC]]), मध्यवर्ती चर असाइन करने की कोई आवश्यकता नहीं है।

— ग्रेगर थॉमस

Answer 7

बहुत आसान ! यहाँ मेरा सुझाव है:

यदि आप अपने कार्यक्षेत्र में डेटाफ्रेम का चयन करना चाहते हैं, तो यह प्रयास करें:

Filter(function(x) is.data.frame(get(x)) , ls())

या

ls()[sapply(ls(), function(x) is.data.frame(get(x)))]

ये सभी समान परिणाम देंगे।

आप is.data.frameअन्य प्रकार के चर की जाँच करने के लिए बदल सकते हैं जैसेis.function

Answer 8

मैं अपने आप को एक पूर्ण नौसिखिया मानता हूं, लेकिन मुझे लगता है कि मेरे पास एक मूल उपशमन का एक बहुत ही सरल उत्तर है जो यहां नहीं कहा गया है: डेटा फ़्रेम, या इसके कुछ हिस्सों तक पहुंचना।

ऊपर बताए अनुसार डेटा फ्रेम के साथ सूची बनाकर शुरू करें:

d1 <- data.frame(y1 = c(1, 2, 3), y2 = c(4, 5, 6))

d2 <- data.frame(y1 = c(3, 2, 1), y2 = c(6, 5, 4))

my.list <- list(d1, d2)

फिर, यदि आप डेटा फ़्रेम में से किसी एक में एक विशिष्ट मान एक्सेस करना चाहते हैं, तो आप क्रमिक रूप से डबल ब्रैकेट का उपयोग करके ऐसा कर सकते हैं। पहला सेट आपको डेटा फ्रेम में मिलता है, और दूसरा सेट आपको विशिष्ट निर्देशांक में मिलता है:

my.list[[1]][[3,2]]

[1] 6