दिलचस्प पोस्ट
ट्रान्सेंडैंटल समीकरण के समाधान की सटीकता में वृद्धि PHP में वजन से यादृच्छिक परिणाम उत्पन्न करना? जावास्क्रिप्ट का उपयोग यूआरएल मान्य करने की कोशिश कर रहा है एक समूह के भीतर एक उपसमूह के लिए अद्वितीय रैंक मान 'गोटो' क्या यह बुरा है? छवि के चारों ओर प्रवाह करने के लिए लेआउट पाठ कैसे करें Rstudio Markdown में वैश्विक पर्यावरण से वस्तुओं का उपयोग कैसे करें "पॉइंटर टू पॉइन्टर टू गैर-कॉन्स्ट" को "पॉइंटर टू पॉइन्टर टू कॉन्स्ट" करने के लिए क्यों यह कानूनी नहीं है? आईओएस – ViewController से ऐप डेलेगेट विधि कॉलिंग विंडोज पर गिट के साथ काम करने के लिए मैं एक संपादक कैसे स्थापित कर सकता हूँ? जावास्क्रिप्ट को प्रतिस्थापित / रेगेक्स मैं वर्तमान से एक अलग कार्य निर्देशिका के साथ प्रोग्राम कैसे चलाऊँ, लिनक्स खोल से? std :: fstream बफरिंग मैनुअल बफरिंग बनाम (क्यों मैनुअल बफरिंग के साथ 10x लाभ)? Wp_nav_menu आइटम में फ़ीचर छवि जोड़ें जावा विधि से कई मान लौटें: क्यों कोई n-tuple ऑब्जेक्ट नहीं है?

एक सूची में data.frame पंक्तियां

मेरे पास एक डेटा.फ्रेम है जिसे मैं पंक्तियों की सूची में परिवर्तित करना चाहूंगा, जिसका अर्थ है कि प्रत्येक पंक्ति अपनी सूची तत्वों के अनुरूप होगी दूसरे शब्दों में, मैं एक सूची चाहूंगा, जब तक कि डेटा। फ्रेम में पंक्तियां होती हैं I

अब तक, मैंने इस समस्या से निम्नलिखित तरीके से निपटने की कोशिश की है, लेकिन मैं सोच रहा था कि इस दृष्टिकोण से बेहतर तरीका क्या है।

xy.df <- data.frame(x = runif(10), y = runif(10)) # pre-allocate a list and fill it with a loop xy.list <- vector("list", nrow(xy.df)) for (i in 1:nrow(xy.df)) { xy.list[[i]] <- xy.df[i,] } 

Solutions Collecting From Web of "एक सूची में data.frame पंक्तियां"

इस कदर:

 xy.list <- split(xy.df, seq(nrow(xy.df))) 

और अगर आप चाहते हैं कि xy.df के xy.df आउटपुट सूची के नाम हैं, तो आप ऐसा कर सकते हैं:

 xy.list <- setNames(split(xy.df, seq(nrow(xy.df))), rownames(xy.df)) 

यूरेका!

 xy.list <- as.list(as.data.frame(t(xy.df))) 

यदि आप data.frame (जैसा मैं करता हूँ) का पूरी तरह से दुरुपयोग करना चाहता हूं और $ कार्यशीलता को रखना चाहते हैं, तो एक तरीका आपको डेटा को विभाजित करना है। एक सूची में इकट्ठे हुए एक-लाइन डेटा.फ्रेम में।

 > df = data.frame(x=c('a','b','c'), y=3:1) > df xy 1 a 3 2 b 2 3 c 1 # 'convert' into a list of data.frames ldf = lapply(as.list(1:dim(df)[1]), function(x) df[x[1],]) > ldf [[1]] xy 1 a 3 [[2]] xy 2 b 2 [[3]] xy 3 c 1 # and the 'coolest' > ldf[[2]]$y [1] 2 

यह केवल बौद्धिक हस्तमैथुन नहीं है, लेकिन डेटा इंडस्ट्री को 'लाइन' की सूची में 'ट्रांसफ़ॉर्म' करने की अनुमति देता है, $ इंडेक्सेशन रखने के लिए जो लैपली के साथ और अधिक उपयोग के लिए उपयोगी हो सकता है (आप जो फ़ैशन को पास करते हैं वह इस $ इंडेक्सेशन का उपयोग करता है)

purrr ( purrr ) पैकेज का वर्तमान संस्करण सबसे तेज़ समाधान है:

 by_row(x, function(v) list(v)[[1L]], .collate = "list")$.out 

सबसे दिलचस्प समाधान की तुलना करते हैं:

 data("Batting", package = "Lahman") x <- Batting[1:10000, 1:10] library(benchr) library(purrr) benchmark( split = split(x, seq_len(.row_names_info(x, 2L))), mapply = .mapply(function(...) structure(list(...), class = "data.frame", row.names = 1L), x, NULL), purrr = by_row(x, function(v) list(v)[[1L]], .collate = "list")$.out ) 

Rsults:

 Benchmark summary: Time units : milliseconds expr n.eval min lw.qu median mean up.qu max total relative split 100 983.0 1060.0 1130.0 1130.0 1180.0 1450 113000 34.3 mapply 100 826.0 894.0 963.0 972.0 1030.0 1320 97200 29.3 purrr 100 24.1 28.6 32.9 44.9 40.5 183 4490 1.0 

इसके अलावा हम Rcpp साथ एक ही परिणाम प्राप्त कर सकते हैं:

 #include <Rcpp.h> using namespace Rcpp; // [[Rcpp::export]] List df2list(const DataFrame& x) { std::size_t nrows = x.rows(); std::size_t ncols = x.cols(); CharacterVector nms = x.names(); List res(no_init(nrows)); for (std::size_t i = 0; i < nrows; ++i) { List tmp(no_init(ncols)); for (std::size_t j = 0; j < ncols; ++j) { switch(TYPEOF(x[j])) { case INTSXP: { if (Rf_isFactor(x[j])) { IntegerVector t = as<IntegerVector>(x[j]); RObject t2 = wrap(t[i]); t2.attr("class") = "factor"; t2.attr("levels") = t.attr("levels"); tmp[j] = t2; } else { tmp[j] = as<IntegerVector>(x[j])[i]; } break; } case LGLSXP: { tmp[j] = as<LogicalVector>(x[j])[i]; break; } case CPLXSXP: { tmp[j] = as<ComplexVector>(x[j])[i]; break; } case REALSXP: { tmp[j] = as<NumericVector>(x[j])[i]; break; } case STRSXP: { tmp[j] = as<std::string>(as<CharacterVector>(x[j])[i]); break; } default: stop("Unsupported type '%s'.", type2name(x)); } } tmp.attr("class") = "data.frame"; tmp.attr("row.names") = 1; tmp.attr("names") = nms; res[i] = tmp; } res.attr("names") = x.attr("row.names"); return res; } 

अब purrr के साथ purrr :

 benchmark( purrr = by_row(x, function(v) list(v)[[1L]], .collate = "list")$.out, rcpp = df2list(x) ) 

परिणाम:

 Benchmark summary: Time units : milliseconds expr n.eval min lw.qu median mean up.qu max total relative purrr 100 25.2 29.8 37.5 43.4 44.2 159.0 4340 1.1 rcpp 100 19.0 27.9 34.3 35.8 37.2 93.8 3580 1.0 

library(purrr) का उपयोग करने वाला एक अन्य विकल्प library(purrr) (जो बड़ी डेटा.फ्रेम पर थोड़ा सा तेज लगता है)

 flatten(by_row(xy.df, ..f = function(x) flatten_chr(x), .labels = FALSE)) 

एक वैकल्पिक तरीका यह है कि डीएफ को मैट्रिक्स में बदल दिया जाए और सूची में आवेदन करने से उस पर ldf <- lapply(as.matrix(myDF), function(x)x) फ़ंक्शन लागू हो: ldf <- lapply(as.matrix(myDF), function(x)x)

मेरे लिए सबसे अच्छा तरीका था:

उदाहरण डेटा:

 Var1<-c("X1",X2","X3") Var2<-c("X1",X2","X3") Var3<-c("X1",X2","X3") Data<-cbind(Var1,Var2,Var3) ID Var1 Var2 Var3 1 X1 X2 X3 2 X4 X5 X6 3 X7 X8 X9 

हम BBmisc लाइब्रेरी कहते हैं

 library(BBmisc) data$lists<-convertRowsToList(data[,2:4]) 

और परिणाम होगा:

 ID Var1 Var2 Var3 lists 1 X1 X2 X3 list("X1", "X2", X3") 2 X4 X5 X6 list("X4","X5", "X6") 3 X7 X8 X9 list("X7,"X8,"X9) 

purrrlyr पैकेज से by_row फ़ंक्शन आपके लिए यह करेंगे।

यह उदाहरण दर्शाता है

 myfn <- function(row) { #row is a tibble with one row, and the same number of columns as the original df l <- as.list(row) return(l) } list_of_lists <- purrrlyr::by_row(df, myfn, .labels=FALSE)$.out 

डिफ़ॉल्ट रूप से, myfn से लौटा मूल्य को df नामक एक नया सूची कॉलम में डाल दिया जाता है। ऊपर दिए गए कथन के अंत में $.out तुरंत इस कॉलम का चयन करता है, सूचियों की सूची लौटाता है

@ फ्लोडेल की तरह लिखा गया: यह आपके डेटाफ्रेम को उस सूची में परिवर्तित करता है जिसमें डेटाफ्रेम में पंक्तियों की संख्या के समान तत्वों की संख्या होती है:

 NewList <- split(df, f = seq(nrow(df))) 

आप केवल उन कॉलमों का चयन करने के लिए फ़ंक्शन जोड़ सकते हैं जो सूची के प्रत्येक तत्व में एनए नहीं हैं :

 NewList2 <- lapply(NewList, function(x) x[,!is.na(x)]) 

एक और अधिक आधुनिक समाधान केवल purrr::transpose का उपयोग करता purrr::transpose :

 library(purrr) iris[1:2,] %>% purrr::transpose() #> [[1]] #> [[1]]$Sepal.Length #> [1] 5.1 #> #> [[1]]$Sepal.Width #> [1] 3.5 #> #> [[1]]$Petal.Length #> [1] 1.4 #> #> [[1]]$Petal.Width #> [1] 0.2 #> #> [[1]]$Species #> [1] 1 #> #> #> [[2]] #> [[2]]$Sepal.Length #> [1] 4.9 #> #> [[2]]$Sepal.Width #> [1] 3 #> #> [[2]]$Petal.Length #> [1] 1.4 #> #> [[2]]$Petal.Width #> [1] 0.2 #> #> [[2]]$Species #> [1] 1