एक सूची को डेटा फ़्रेम में परिवर्तित करें

Question

मेरे पास डेटा की नेस्टेड सूची है। इसकी लंबाई 132 है और प्रत्येक आइटम लंबाई 20 की एक सूची है। क्या इस संरचना को एक डेटा फ्रेम में बदलने का एक त्वरित तरीका है जिसमें 132 पंक्तियाँ और 20 कॉलम डेटा हैं?

यहाँ कुछ नमूना डेटा के साथ काम करना है:

l <- replicate(
  132,
  list(sample(letters, 20)),
  simplify = FALSE
)

Comments

तो आप अपने डेटा.फ्रेम में डेटा की एक पंक्ति के रूप में प्रत्येक सूची तत्व चाहते हैं?

— जोशुआ उलरिच

@ रीचीकॉटन यह सही उदाहरण नहीं है। "प्रत्येक आइटम की लंबाई 20 की एक सूची है" और आपको प्रत्येक आइटम की लंबाई 20 के वेक्टर की एक तत्व सूची है ।

— मैर्क

पार्टी के लिए देर हो चुकी है, लेकिन मैं नहीं देखा किसी को भी उल्लेख इस , जो मैंने सोचा था कि बहुत आसान था (जो मैं काम करना चाहते थे के लिए)।

— mflo-ByeSE

डेटा.फ्रेम विधि के लिए सबसे कुशल सूची

— हेनरिक

में उल्लेख किया r-bloggers.com/converting-a-list-to-a-data-frame

— 千木郷

Answer 1

अपनी सूची की सूची को कहते हैं l:

df <- data.frame(matrix(unlist(l), nrow=length(l), byrow=T))

उपरोक्त सभी वर्ण स्तंभों को कारकों में बदल देगा, इससे बचने के लिए आप डेटा.फ्रेम () कॉल में एक पैरामीटर जोड़ सकते हैं:

df <- data.frame(matrix(unlist(l), nrow=132, byrow=T),stringsAsFactors=FALSE)

Comments

यदि आपका डेटा सभी एक ही प्रकार का नहीं है, तो यहां सावधानी बरतें। मैट्रिक्स से गुजरने का मतलब है कि सभी डेटा को एक सामान्य प्रकार में ले जाया जाएगा। Ie यदि आपके पास वर्ण डेटा का एक स्तंभ और संख्यात्मक डेटा का एक स्तंभ है तो संख्यात्मक डेटा को स्ट्रिंग द्वारा मैट्रिक्स () और फिर दोनों द्वारा data.frame () द्वारा कारक के लिए बाध्य किया जाएगा।

— इयान सुडरबी

ऐसा करने का सबसे अच्छा तरीका क्या है जहां सूची में लापता मूल्य हैं, या डेटा फ्रेम में एनए को शामिल करने के लिए?

— डेव

@Dave: मेरे लिए काम करता है ... यहाँ देखें r-fiddle.org/#/fiddle?id=y8DW7lqL&version=3

— nico

यह भी ध्यान रखें कि यदि आपके पास चरित्र डेटा प्रकार है - data.frame इसे कारकों में बदल देगा।

— एलेक्स ब्राउन

@ nico क्या सूची तत्वों के नामों को df में कॉलनाम या रोने के नाम के रूप में रखने का कोई तरीका है?

— एन। वीरेला

Answer 2

साथ में rbind

do.call(rbind.data.frame, your_list)

संपादित करें: पिछला संस्करण वापसी data.frameकी list'वैक्टर के बजाय है (जैसा कि @IanSudbery टिप्पणी में कहा)।

Comments

यह काम क्यों करता है लेकिन rbind(your_list)1x32 सूची मैट्रिक्स लौटाता है?

— पलक

@eykanal तर्कों के do.callतत्वों को पास करता your_listहै rbind। इसके बराबर है rbind(your_list[[1]], your_list[[2]], your_list[[3]], ....., your_list[[length of your_list]])।

— मारेक

यह विधि अशक्त स्थिति से ग्रस्त है।

— फ्रैंक वांग

@FrankWANG लेकिन यह विधि शून्य स्थिति के लिए डिज़ाइन नहीं की गई है। यह आवश्यक है कि your_listसमान आकार के वैक्टर हों। NULLलंबाई 0 है इसलिए यह विफल होना चाहिए।

— मारेक

यह विधि सही ऑब्जेक्ट को वापस करने के लिए प्रतीत होती है, लेकिन ऑब्जेक्ट का निरीक्षण करने पर, आप पाएंगे कि कॉलम वैक्टर के बजाय सूचियां हैं, जो लाइन की समस्याओं को जन्म दे सकती हैं यदि आप इसकी उम्मीद नहीं कर रहे हैं।

— इयान सुद्रेबी

Answer 3

आप plyrपैकेज का उपयोग कर सकते हैं । उदाहरण के लिए फॉर्म की नेस्टेड सूची

l <- list(a = list(var.1 = 1, var.2 = 2, var.3 = 3)
      , b = list(var.1 = 4, var.2 = 5, var.3 = 6)
      , c = list(var.1 = 7, var.2 = 8, var.3 = 9)
      , d = list(var.1 = 10, var.2 = 11, var.3 = 12)
      )

अब 4 की लंबाई है और प्रत्येक सूची में lलंबाई 3 की एक और सूची है। अब आप चला सकते हैं

  library (plyr)
  df <- ldply (l, data.frame)

और उत्तर @Marek और @nico के समान परिणाम प्राप्त करना चाहिए।

Comments

बहुत बढ़िया जवाब। मैं आपको थोड़ा समझा सकता हूं कि यह कैसे काम करता है? यह बस प्रत्येक सूची प्रविष्टि के लिए एक डेटा फ्रेम देता है?

— माइकल बार्टन

Imho सबसे अच्छा जवाब। यह एक ईमानदार data.frame देता है। सभी डेटा प्रकार (वर्ण, संख्यात्मक, आदि) सही रूप से रूपांतरित हैं। यदि सूची में अलग-अलग डेटा प्रकार हैं, तो वे सभी matrixदृष्टिकोण के साथ चरित्र में बदल जाएंगे ।

— 14

यहाँ दिया गया नमूना प्रश्न द्वारा प्रदान किया गया एक नहीं है। मूल डेटासेट पर इस उत्तर का परिणाम गलत है।

— MySchizoBuddy

मेरे लिए महान काम करता है! और परिणामस्वरूप डेटा फ़्रेम में कॉलम के नाम सेट किए गए हैं! टीएक्स

— बान

प्लायर मल्टीकोर है? या वहाँ mclapply के साथ उपयोग के लिए एक lapply संस्करण है?

— गार्सालैप

Answer 4

data.frame(t(sapply(mylistlist,c)))

sapplyइसे एक मैट्रिक्स में परिवर्तित करता है। data.frameमैट्रिक्स को डेटा फ़्रेम में परिवर्तित करता है।

Comments

अब तक का सबसे अच्छा जवाब! अन्य समाधानों में से कोई भी प्रकार / स्तंभ नाम सही नहीं मिलता है। धन्यवाद!

— d_a_c321

आप cयहाँ क्या भूमिका निभाने का इरादा कर रहे हैं, सूची के डेटा का एक उदाहरण? ओह रुको, समवर्ती कार्य के लिए ग? @ Mnel के c के उपयोग से भ्रमित हो रहे हैं। मैं @dchandler के साथ भी सहमत हूं, कॉलम नाम सही होना मेरे उपयोग के मामले में एक मूल्यवान आवश्यकता थी। शानदार समाधान।

— jxramos

यह सही है - मानक सी फ़ंक्शन; से ?c:Combine Values into a Vector or List

— एलेक्स ब्राउन

प्रश्न में दिए गए नमूना डेटा के साथ काम नहीं करता है

— MySchizoBuddy

क्या यह सूचियों का डेटा.फ्रेम उत्पन्न नहीं करता है?

— कार्ल

Answer 5

मान लें कि आपकी सूची को कहा जाता है L,

data.frame(Reduce(rbind, L))

Comments

अच्छा है! आपकी तुलना में @ एलेक्स ब्राउन के समाधान के साथ एक अंतर है, आपके मार्ग से किसी कारण के लिए निम्न चेतावनी संदेश प्राप्त होता है: `चेतावनी संदेश: data.row.names (row.names, rowi, i) में: कुछ row.names : 3,4 -> row.names नहीं इस्तेमाल किया '

— jxramos

बहुत अच्छा!! मेरे लिए यहाँ काम किया: stackoverflow.com/questions/32996321/…

— अनस्तासिया पुपिनिना

अच्छी तरह से काम करता है जब तक कि सूची में केवल एक तत्व न हो: 2 पंक्तियों केdata.frame(Reduce(rbind, list(c('col1','col2')))) साथ एक डेटा फ़्रेम का उत्पादन करता है , 1 कॉलम (मुझे 1 पंक्ति 2 कॉलम की उम्मीद है)

— लाल मटर

Answer 6

पैकेज data.tableमें फ़ंक्शन rbindlistहोता है जो एक सुपरफास्ट कार्यान्वयन है do.call(rbind, list(...))।

यह की एक सूची ले जा सकते हैं lists, data.framesया data.tables इनपुट के रूप में।

library(data.table)
ll <- list(a = list(var.1 = 1, var.2 = 2, var.3 = 3)
  , b = list(var.1 = 4, var.2 = 5, var.3 = 6)
  , c = list(var.1 = 7, var.2 = 8, var.3 = 9)
  , d = list(var.1 = 10, var.2 = 11, var.3 = 12)
  )

DT <- rbindlist(ll)

इससे data.tableविरासत मिलती है data.frame।

यदि आप वास्तव में वापस data.frame उपयोग में कनवर्ट करना चाहते हैंas.data.frame(DT)

Comments

अंतिम पंक्ति के बारे में, setDFअब संदर्भ द्वारा data.frame पर लौटने की अनुमति देता है।

— फ्रैंक

30k आइटम के साथ मेरी सूची के लिए, rbindlist ने ldply की तुलना में तेजी से काम किया

— लम्बे

Answer 7

tibbleपैकेज एक समारोह है enframe()कि हल करती है नेस्टेड मजबूर करके इस समस्या का listनेस्ट करने के लिए वस्तुओं tibble( "साफ" डेटा फ्रेम) वस्तुओं। डेटा विज्ञान के लिए आर से एक संक्षिप्त उदाहरण यहां दिया गया है :

x <- list(
    a = 1:5,
    b = 3:4, 
    c = 5:6
) 

df <- enframe(x)
df
#> # A tibble: 3 × 2
#>    name     value
#>   <chr>    <list>
#>    1     a <int [5]>
#>    2     b <int [2]>
#>    3     c <int [2]>

चूंकि आपके पास अपनी सूची में कई घोंसले हैं l, आप unlist(recursive = FALSE)केवल एक पदानुक्रमित सूची प्राप्त करने के लिए अनावश्यक घोंसले को हटाने के लिए उपयोग कर सकते हैं और फिर पास कर सकते हैं enframe()। मैं tidyr::unnest()आउटपुट को एक एकल "साफ" डेटा फ्रेम में बेकार करना चाहता हूं , जिसमें आपके दो कॉलम हैं (समूह के nameलिए एक और समूहों के साथ टिप्पणियों के लिए एक value)। यदि आप ऐसे स्तंभ चाहते हैं, जो विस्तृत हों, तो आप स्तंभ का उपयोग कर जोड़ सकते हैं, add_column()जो केवल 132 बार मानों के क्रम को दोहराता है। फिर सिर्फ spread()मूल्य।

library(tidyverse)

l <- replicate(
    132,
    list(sample(letters, 20)),
    simplify = FALSE
)

l_tib <- l %>% 
    unlist(recursive = FALSE) %>% 
    enframe() %>% 
    unnest()
l_tib
#> # A tibble: 2,640 x 2
#>     name value
#>    <int> <chr>
#> 1      1     d
#> 2      1     z
#> 3      1     l
#> 4      1     b
#> 5      1     i
#> 6      1     j
#> 7      1     g
#> 8      1     w
#> 9      1     r
#> 10     1     p
#> # ... with 2,630 more rows

l_tib_spread <- l_tib %>%
    add_column(index = rep(1:20, 132)) %>%
    spread(key = index, value = value)
l_tib_spread
#> # A tibble: 132 x 21
#>     name   `1`   `2`   `3`   `4`   `5`   `6`   `7`   `8`   `9`  `10`  `11`
#> *  <int> <chr> <chr> <chr> <chr> <chr> <chr> <chr> <chr> <chr> <chr> <chr>
#> 1      1     d     z     l     b     i     j     g     w     r     p     y
#> 2      2     w     s     h     r     i     k     d     u     a     f     j
#> 3      3     r     v     q     s     m     u     j     p     f     a     i
#> 4      4     o     y     x     n     p     i     f     m     h     l     t
#> 5      5     p     w     v     d     k     a     l     r     j     q     n
#> 6      6     i     k     w     o     c     n     m     b     v     e     q
#> 7      7     c     d     m     i     u     o     e     z     v     g     p
#> 8      8     f     s     e     o     p     n     k     x     c     z     h
#> 9      9     d     g     o     h     x     i     c     y     t     f     j
#> 10    10     y     r     f     k     d     o     b     u     i     x     s
#> # ... with 122 more rows, and 9 more variables: `12` <chr>, `13` <chr>,
#> #   `14` <chr>, `15` <chr>, `16` <chr>, `17` <chr>, `18` <chr>,
#> #   `19` <chr>, `20` <chr>

Comments

ओपी का हवाला देते हुए: "क्या इस संरचना को एक डेटा फ्रेम में बदलने का एक त्वरित तरीका है जिसमें 132 पंक्तियाँ और डेटा के 20 स्तंभ हैं?" तो शायद आपको एक फैलने वाले कदम या कुछ और की जरूरत है।

— फ्रैंक

आह हां, बस एक इंडेक्स कॉलम होना चाहिए जो फैल सकता है। मैं जल्द ही अपडेट करूंगा।

— मैट डैनचो

Answer 8

आपकी सूचियों की संरचना के आधार पर कुछ tidyverseविकल्प हैं जो असमान लंबाई की सूचियों के साथ अच्छी तरह से काम करते हैं:

l <- list(a = list(var.1 = 1, var.2 = 2, var.3 = 3)
        , b = list(var.1 = 4, var.2 = 5)
        , c = list(var.1 = 7, var.3 = 9)
        , d = list(var.1 = 10, var.2 = 11, var.3 = NA))

df <- dplyr::bind_rows(l)
df <- purrr::map_df(l, dplyr::bind_rows)
df <- purrr::map_df(l, ~.x)

# all create the same data frame:
# A tibble: 4 x 3
  var.1 var.2 var.3
  <dbl> <dbl> <dbl>
1     1     2     3
2     4     5    NA
3     7    NA     9
4    10    11    NA

आप वैक्टर और डेटा फ्रेम भी मिला सकते हैं:

library(dplyr)
bind_rows(
  list(a = 1, b = 2),
  data_frame(a = 3:4, b = 5:6),
  c(a = 7)
)

# A tibble: 4 x 2
      a     b
  <dbl> <dbl>
1     1     2
2     3     5
3     4     6
4     7    NA

Comments

यह dplyr :: bind_rows फ़ंक्शन अच्छी तरह से काम करता है, यहां तक ​​कि JSON के रूप में उत्पन्न होने वाली सूचियों के साथ काम करना मुश्किल है। JSON से आश्चर्यजनक रूप से स्वच्छ डेटाफ़्रेम में। अच्छा लगा।

— GGAnderson

@sbha मैंने df <- purrr :: map_df (l, ~ .x) का उपयोग करने की कोशिश की, लेकिन ऐसा लगता है कि इसका काम नहीं कर रहा है, त्रुटि संदेश मेरे पास है त्रुटि: स्तंभ X2को पूर्णांक से वर्ण में परिवर्तित नहीं किया जा सकता

— Jolin

Answer 9

Reshape2 ऊपर plyr उदाहरण के रूप में एक ही उत्पादन देता है:

library(reshape2)
l <- list(a = list(var.1 = 1, var.2 = 2, var.3 = 3)
          , b = list(var.1 = 4, var.2 = 5, var.3 = 6)
          , c = list(var.1 = 7, var.2 = 8, var.3 = 9)
          , d = list(var.1 = 10, var.2 = 11, var.3 = 12)
)
l <- melt(l)
dcast(l, L1 ~ L2)

पैदावार:

  L1 var.1 var.2 var.3
1  a     1     2     3
2  b     4     5     6
3  c     7     8     9
4  d    10    11    12

यदि आप लगभग पिक्सल के बाहर थे आप सकता है 1 लाइन w / मरम्मत () में यह सब करते हैं।

Answer 10

यह विधि एक tidyverseपैकेज ( purrr ) का उपयोग करती है ।

सूचि:

x <- as.list(mtcars)

इसे एक डेटा फ्रेम ( tibbleविशेष रूप से) में परिवर्तित करना :

library(purrr)
map_df(x, ~.x)

Answer 11

@ मर्क के उत्तर पर विस्तार: यदि आप तार को कारकों में बदलने से बचना चाहते हैं और दक्षता चिंता का विषय नहीं है

do.call(rbind, lapply(your_list, data.frame, stringsAsFactors=FALSE))

Answer 12

एक नेस्टेड JSON से प्राप्त की तरह 3 या अधिक स्तरों के साथ गहरी नेस्टेड सूचियों के सामान्य मामले के लिए :

{
"2015": {
  "spain": {"population": 43, "GNP": 9},
  "sweden": {"population": 7, "GNP": 6}},
"2016": {
  "spain": {"population": 45, "GNP": 10},
  "sweden": {"population": 9, "GNP": 8}}
}

melt()नेस्टेड सूची को पहले एक लंबे प्रारूप में बदलने के लिए दृष्टिकोण पर विचार करें :

myjson <- jsonlite:fromJSON(file("test.json"))
tall <- reshape2::melt(myjson)[, c("L1", "L2", "L3", "value")]
    L1     L2         L3 value
1 2015  spain population    43
2 2015  spain        GNP     9
3 2015 sweden population     7
4 2015 sweden        GNP     6
5 2016  spain population    45
6 2016  spain        GNP    10
7 2016 sweden population     9
8 2016 sweden        GNP     8

इसके dcast()बाद फिर से एक सुव्यवस्थित डाटासेट में फिर से चौड़ा करने के लिए जहां प्रत्येक चर एक स्तंभ बनाता है और प्रत्येक अवलोकन एक पंक्ति बनाता है:

wide <- reshape2::dcast(tall, L1+L2~L3) 
# left side of the formula defines the rows/observations and the 
# right side defines the variables/measurements
    L1     L2 GNP population
1 2015  spain   9         43
2 2015 sweden   6          7
3 2016  spain  10         45
4 2016 sweden   8          9

Answer 13

इस सवाल के जवाब में समय के साथ-साथ और अधिक जवाब: एक सूची को डेटा फ्रेम के रूप में डालने का सबसे कुशल तरीका क्या है?

सबसे तेज़ तरीका, स्तंभों के लिए वैक्टर के बजाय सूचियों के साथ डेटाफ़्रेम का उत्पादन नहीं करता है (मार्टिन मॉर्गन के उत्तर से) प्रतीत होता है:

l <- list(list(col1="a",col2=1),list(col1="b",col2=2))
f = function(x) function(i) unlist(lapply(x, `[[`, i), use.names=FALSE)
as.data.frame(Map(f(l), names(l[[1]])))

Answer 14

कभी-कभी आपका डेटा समान लंबाई के वैक्टर की सूची में शामिल हो सकता है।

lolov = list(list(c(1,2,3),c(4,5,6)), list(c(7,8,9),c(10,11,12),c(13,14,15)) )

(भीतरी वैक्टर भी सूचियाँ हो सकती हैं, लेकिन मैं इसे पढ़ने में आसान बनाने के लिए सरल कर रहा हूँ)।

फिर आप निम्न संशोधन कर सकते हैं। याद रखें कि आप एक समय में एक स्तर प्राप्त कर सकते हैं:

lov = unlist(lolov, recursive = FALSE )
> lov
[[1]]
[1] 1 2 3

[[2]]
[1] 4 5 6

[[3]]
[1] 7 8 9

[[4]]
[1] 10 11 12

[[5]]
[1] 13 14 15

अब अन्य उत्तरों में उल्लिखित अपनी पसंदीदा विधि का उपयोग करें:

library(plyr)
>ldply(lov)
  V1 V2 V3
1  1  2  3
2  4  5  6
3  7  8  9
4 10 11 12
5 13 14 15

Answer 15

यह वही है जो आखिरकार मेरे लिए काम करता है:

do.call("rbind", lapply(S1, as.data.frame))

Answer 16

l <- replicate(10,list(sample(letters, 20)))
a <-lapply(l[1:10],data.frame)
do.call("cbind", a)

Answer 17

समाधान के purrrपरिवार का उपयोग करते हुए एक समरूप (मल्टीकोर, मल्टीसेशन, आदि) समाधान के लिए:

library (furrr)
plan(multisession) # see below to see which other plan() is the more efficient
myTibble <- future_map_dfc(l, ~.x)

lसूची कहां है

सबसे कुशल plan()आप उपयोग कर सकते हैं बेंचमार्क करने के लिए:

library(tictoc)
plan(sequential) # reference time
# plan(multisession) # benchamark plan() goes here. See ?plan().
tic()
myTibble <- future_map_dfc(l, ~.x)
toc()

Answer 18

मेरे लिए निम्न सरल कमांड ने काम किया:

myDf <- as.data.frame(myList)

संदर्भ ( Quora उत्तर )

> myList <- list(a = c(1, 2, 3), b = c(4, 5, 6))
> myList
$a
[1] 1 2 3

$b
[1] 4 5 6

> myDf <- as.data.frame(myList)
  a b
1 1 4
2 2 5
3 3 6
> class(myDf)
[1] "data.frame"

लेकिन यह विफल हो जाएगा अगर यह स्पष्ट नहीं है कि सूची को डेटा फ्रेम में कैसे परिवर्तित किया जाए:

> myList <- list(a = c(1, 2, 3), b = c(4, 5, 6, 7))
> myDf <- as.data.frame(myList)
Error in (function (..., row.names = NULL, check.rows = FALSE, check.names = TRUE,  : 
  arguments imply differing number of rows: 3, 4

नोट : उत्तर प्रश्न के शीर्षक की ओर है और प्रश्न के कुछ विवरणों को छोड़ सकता है

Comments

ध्यान दें कि प्रश्न से इनपुट पर यह केवल काम करता है। ओपी 132 पंक्तियों और 20 कॉलमों के लिए कहता है, लेकिन यह 20 पंक्तियों और 132 कॉलमों को देता है।

— ग्रेगर थॉमस

अलग-अलग लंबाई के इनपुट के साथ आपके उदाहरण के लिए, जहां यह विफल हो जाता है, यह स्पष्ट नहीं है कि वांछित परिणाम क्या होगा ...

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

@ ग्रेगोर ट्रू, लेकिन प्रश्न का शीर्षक "डेटा फ्रेम में आर - सूची" है। प्रश्न के कई आगंतुक और जिन्होंने इसे वोट दिया, उनके पास ओपी की सटीक समस्या नहीं है। प्रश्न शीर्षक के आधार पर, वे सूची को डेटा फ़्रेम में बदलने का एक तरीका खोजते हैं। मुझे खुद भी यही समस्या थी और मैंने जो समाधान पोस्ट किया था, उसने मेरी समस्या हल कर दी

— अहमद

हाँ, सिर्फ ध्यान देना। नीच नहीं। उत्तर में यह नोट करना अच्छा हो सकता है कि यह कुछ ऐसा ही करता है - लेकिन विशिष्ट रूप से भिन्न - सभी अन्य उत्तरों से बहुत अधिक।

— ग्रेगर थॉमस

Answer 19

ऐसा करने का एक छोटा (लेकिन शायद सबसे तेज़ नहीं) तरीका आधार आर का उपयोग करना होगा, क्योंकि एक डेटा फ्रेम सिर्फ समान लंबाई वाले डॉक्टरों की एक सूची है । इस प्रकार आपकी इनपुट सूची और 30 x 132 डेटा.फ्रेम के बीच रूपांतरण होगा:

df <- data.frame(l)

वहां से हम इसे 132 x 30 मैट्रिक्स में स्थानांतरित कर सकते हैं, और इसे वापस डेटाफ़्रेम में बदल सकते हैं:

new_df <- data.frame(t(df))

एक-लाइनर के रूप में:

new_df <- data.frame(t(data.frame(l)))

उपद्रवी देखने में बहुत कष्टप्रद होंगे, लेकिन आप हमेशा उन लोगों का नाम बदल सकते हैं

rownames(new_df) <- 1:nrow(new_df)

Comments

इसे क्यों ठुकरा दिया गया? मैं जानना चाहता हूं इसलिए मैं गलत सूचना नहीं फैलाता।

— विल C

मैंने पहले भी ऐसा किया है, डेटा.फ्रेम और टी के संयोजन का उपयोग करके! मुझे लगता है कि जो लोग निराश थे उन्हें लगता है कि बेहतर तरीके हैं, विशेष रूप से वे जो नामों को गड़बड़ नहीं करते हैं।

— आर्थर यिप

यह एक अच्छी बात है, मुझे लगता है कि यह गलत भी है यदि आप अपनी सूची में नाम सुरक्षित रखना चाहते हैं।

— विल C

Answer 20

map_एक forलूप के साथ फ़ंक्शन का उपयोग करने के बारे में कैसे ? यहाँ मेरा समाधान है:

list_to_df <- function(list_to_convert) {
  tmp_data_frame <- data.frame()
  for (i in 1:length(list_to_convert)) {
    tmp <- map_dfr(list_to_convert[[i]], data.frame)
    tmp_data_frame <- rbind(tmp_data_frame, tmp)
  }
  print(tmp_data_frame)
}

जहां map_dfrसूची तत्व में से प्रत्येक को data.frame में परिवर्तित करें और फिर rbindउन्हें पूरी तरह से संघ करें।

आपके मामले में, मुझे लगता है कि यह होगा:

converted_list <- list_to_df(l)