कैसे एक महान आर प्रतिलिपि प्रस्तुत करने योग्य उदाहरण बनाने के लिए


2473

सहयोगियों के साथ प्रदर्शन पर चर्चा करते समय, शिक्षण, बग रिपोर्ट भेजना या मेलिंग सूचियों पर मार्गदर्शन के लिए खोज करना और यहां स्टैक ओवरफ्लो पर, एक प्रतिलिपि प्रस्तुत करने योग्य उदाहरण अक्सर पूछा जाता है और हमेशा मददगार होता है।

एक उत्कृष्ट उदाहरण बनाने के लिए आपके सुझाव क्या हैं? आप डेटा संरचनाओं को कैसे चिपकाते हैंएक पाठ प्रारूप में? आपको और कौन सी जानकारी शामिल करनी चाहिए?

वहाँ का उपयोग करने के अलावा अन्य चालें हैं dput(), dump()या structure()? आपको कब शामिल करना चाहिए library()या require()कथन? कौन सा शब्द आरक्षित चाहिए एक से बचने के अलावा करने के लिए c, df, data, आदि?

कैसे एक महान बनाता है प्रजनन योग्य उदाहरण?


34
मैं सवाल के दायरे को लेकर उलझन में हूं। लोग SO या R- मदद (कैसे "त्रुटि को पुन: उत्पन्न करने के लिए") पर प्रश्न पूछने में प्रतिलिपि प्रस्तुत करने योग्य उदाहरण की व्याख्या पर कूद गए हैं। मदद पृष्ठों में प्रतिलिपि प्रस्तुत करने योग्य आर उदाहरणों के बारे में क्या? पैकेज डेमो में? ट्यूटोरियल / प्रस्तुतियों में?
बपतिस्मा

15
@ बपतिस्मा देने वाला: एक ही ऋण त्रुटि। मेरे द्वारा बताई गई सभी तकनीकों का उपयोग पैकेज सहायता पृष्ठों में किया जाता है, और ट्यूटोरियल और प्रस्तुतियों में मैं आर
जोरिस मेय्स

33
डेटा कभी-कभी सीमित कारक होता है, क्योंकि संरचना अनुकरण करने के लिए बहुत जटिल हो सकती है। निजी डेटा से सार्वजनिक डेटा का उत्पादन करने के लिए: stackoverflow.com/a/10458688/742447 में stackoverflow.com/questions/10454973/…
Etienne लो-डेकेरी

जवाबों:


1726

एक न्यूनतम प्रजनन योग्य उदाहरण में निम्नलिखित वस्तुएं शामिल हैं:

  • समस्या को प्रदर्शित करने के लिए आवश्यक न्यूनतम डेटासेट
  • त्रुटि को पुन: उत्पन्न करने के लिए आवश्यक न्यूनतम रननीय कोड, जिसे दिए गए डेटासेट पर चलाया जा सकता है
  • उपयोग किए गए पैकेज, आर संस्करण और सिस्टम पर आवश्यक जानकारी इसे चलाया जाता है।
  • यादृच्छिक प्रक्रियाओं के मामले में, set.seed()प्रजनन के लिए एक बीज (सेट द्वारा ) 1

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

न्यूनतम डेटासेट का उत्पादन करना

अधिकांश मामलों के लिए, यह केवल कुछ मानों के साथ एक वेक्टर / डेटा फ्रेम प्रदान करके आसानी से किया जा सकता है। या आप बिल्ट-इन डेटासेट्स में से एक का उपयोग कर सकते हैं, जो अधिकांश पैकेजों के साथ प्रदान किए जाते हैं।
अंतर्निहित डेटासेट की एक व्यापक सूची के साथ देखा जा सकता है library(help = "datasets")। प्रत्येक डेटासेट के लिए एक संक्षिप्त विवरण होता है और उदाहरण के लिए अधिक जानकारी प्राप्त की जा सकती है ?mtcarsजहां 'mtcars' सूची में डेटासेट में से एक है। अन्य पैकेजों में अतिरिक्त डेटासेट हो सकते हैं।

एक वेक्टर बनाना आसान है। कभी-कभी इसमें कुछ यादृच्छिकता जोड़ना आवश्यक होता है, और इसे बनाने के लिए कई प्रकार के कार्य होते हैं। sample()एक वेक्टर यादृच्छिक कर सकते हैं, या कुछ ही मूल्यों के साथ एक यादृच्छिक वेक्टर दे सकते हैं। lettersएक उपयोगी वेक्टर है जिसमें वर्णमाला होती है। इसका उपयोग कारक बनाने के लिए किया जा सकता है।

कुछ उदाहरण:

  • यादृच्छिक मूल्य: x <- rnorm(10)सामान्य वितरण के लिए, x <- runif(10)समान वितरण के लिए, ...
  • कुछ मूल्यों का क्रमचय: x <- sample(1:10)वेक्टर 1:10 के लिए यादृच्छिक क्रम में।
  • एक यादृच्छिक कारक: x <- sample(letters[1:4], 20, replace = TRUE)

मैट्रिसेस के लिए, कोई भी उपयोग कर सकता है matrix(), जैसे:

matrix(1:10, ncol = 2)

डेटा फ्रेम बनाना का उपयोग करके किया जा सकता है data.frame()। डेटा फ्रेम में प्रविष्टियों के नाम पर ध्यान देना चाहिए, और इसे अत्यधिक जटिल नहीं बनाना चाहिए।

एक उदाहरण :

set.seed(1)
Data <- data.frame(
    X = sample(1:10),
    Y = sample(c("yes", "no"), 10, replace = TRUE)
)

कुछ सवालों के लिए, विशिष्ट स्वरूपों की आवश्यकता हो सकती है। इन के लिए, एक प्रदान की के किसी भी उपयोग कर सकते हैं as.someType: कार्यों as.factor, as.Date, as.xtsवेक्टर और / या डेटा फ्रेम चाल के साथ संयोजन में, ... ये।

अपना डेटा कॉपी करें

आप कुछ डेटा है कि इन सुझावों का उपयोग निर्माण के लिए भी मुश्किल होगा है, तो आप हमेशा अपने मूल डेटा का एक उप कर सकते हैं, का उपयोग कर head(), subset()या सूचकांक। फिर dput()हमें कुछ ऐसा देने के लिए उपयोग करें जिसे तुरंत आर में रखा जा सकता है:

> dput(iris[1:4, ]) # first four rows of the iris data set
structure(list(Sepal.Length = c(5.1, 4.9, 4.7, 4.6), Sepal.Width = c(3.5, 
3, 3.2, 3.1), Petal.Length = c(1.4, 1.4, 1.3, 1.5), Petal.Width = c(0.2, 
0.2, 0.2, 0.2), Species = structure(c(1L, 1L, 1L, 1L), .Label = c("setosa", 
"versicolor", "virginica"), class = "factor")), .Names = c("Sepal.Length", 
"Sepal.Width", "Petal.Length", "Petal.Width", "Species"), row.names = c(NA, 
4L), class = "data.frame")

यदि आपके डेटा फ़्रेम में कई स्तरों के साथ एक कारक है, तो dputआउटपुट अनजाना हो सकता है क्योंकि यह अभी भी सभी संभावित कारक स्तरों को सूचीबद्ध करेगा, भले ही वे आपके डेटा के सबसेट में मौजूद न हों। इस समस्या को हल करने के लिए, आप droplevels()फ़ंक्शन का उपयोग कर सकते हैं । नीचे दी गई सूचना कि कैसे प्रजातियां केवल एक स्तर के साथ एक कारक हैं:

> dput(droplevels(iris[1:4, ]))
structure(list(Sepal.Length = c(5.1, 4.9, 4.7, 4.6), Sepal.Width = c(3.5, 
3, 3.2, 3.1), Petal.Length = c(1.4, 1.4, 1.3, 1.5), Petal.Width = c(0.2, 
0.2, 0.2, 0.2), Species = structure(c(1L, 1L, 1L, 1L), .Label = "setosa",
class = "factor")), .Names = c("Sepal.Length", "Sepal.Width", 
"Petal.Length", "Petal.Width", "Species"), row.names = c(NA, 
4L), class = "data.frame")

उपयोग करते समय dput, आप केवल प्रासंगिक कॉलम को शामिल करना चाह सकते हैं:

> dput(mtcars[1:3, c(2, 5, 6)]) # first three rows of columns 2, 5, and 6
structure(list(cyl = c(6, 6, 4), drat = c(3.9, 3.9, 3.85), wt = c(2.62, 
2.875, 2.32)), row.names = c("Mazda RX4", "Mazda RX4 Wag", "Datsun 710"
), class = "data.frame")

इसके लिए एक अन्य चेतावनी dputयह है कि यह कुंजीकृत data.tableवस्तुओं के लिए या समूह tbl_df(वर्ग grouped_df) से काम नहीं करेगा dplyr। इन मामलों में आप, साझा करने से पहले एक नियमित रूप से डेटा फ्रेम करने के लिए वापस परिवर्तित कर सकते हैं dput(as.data.frame(my_data))

सबसे खराब स्थिति में, आप एक पाठ प्रतिनिधित्व दे सकते हैं जिसे textपैरामीटर के उपयोग से पढ़ा जा सकता है read.table:

zz <- "Sepal.Length Sepal.Width Petal.Length Petal.Width Species
1          5.1         3.5          1.4         0.2  setosa
2          4.9         3.0          1.4         0.2  setosa
3          4.7         3.2          1.3         0.2  setosa
4          4.6         3.1          1.5         0.2  setosa
5          5.0         3.6          1.4         0.2  setosa
6          5.4         3.9          1.7         0.4  setosa"

Data <- read.table(text=zz, header = TRUE)

न्यूनतम कोड का उत्पादन

यह आसान हिस्सा होना चाहिए, लेकिन अक्सर ऐसा नहीं होता है। आपको जो नहीं करना चाहिए, वह है:

  • सभी प्रकार के डेटा रूपांतरण जोड़ें। सुनिश्चित करें कि प्रदान किया गया डेटा पहले से ही सही प्रारूप में है (जब तक कि समस्या की समस्या न हो)
  • एक संपूर्ण फ़ंक्शन / कोड का कोड कॉपी-पेस्ट करें जो एक त्रुटि देता है। सबसे पहले, यह पता लगाने की कोशिश करें कि कौन सी लाइनें त्रुटि का परिणाम हैं। अधिक बार आप यह नहीं जान पाएंगे कि समस्या स्वयं क्या है।

आपको क्या करना चाहिए, यह है:

  • यदि आप किसी भी (उपयोग library()) का उपयोग करते हैं तो कौन से पैकेज का उपयोग किया जाना चाहिए
  • यदि आप कनेक्शन खोलते हैं या फ़ाइलें बनाते हैं, तो उन्हें बंद करने या फ़ाइलों को हटाने के लिए कुछ कोड जोड़ें (उपयोग करके unlink())
  • यदि आप विकल्प बदलते हैं, तो सुनिश्चित करें कि कोड में मूल लोगों को वापस करने के लिए एक कथन शामिल है। (उदा op <- par(mfrow=c(1,2)) ...some code... par(op))
  • कोड को चलाने योग्य बनाने के लिए अपने कोड को एक नए, खाली R सत्र में चलाएं। लोग कंसोल में आपके डेटा और आपके कोड को केवल कॉपी-पेस्ट करने में सक्षम होना चाहिए और आपके पास बिल्कुल वैसा ही होना चाहिए जैसा आपके पास है।

अतिरिक्त जानकारी दें

ज्यादातर मामलों में, बस आर संस्करण और ऑपरेटिंग सिस्टम पर्याप्त होगा। जब पैकेजों के साथ टकराव पैदा होता है, तो आउटपुट sessionInfo()वास्तव में मदद कर सकता है। अन्य अनुप्रयोगों के कनेक्शन के बारे में बात करते समय (यह ओडीबीसी या कुछ और के माध्यम से हो), एक को उन लोगों के लिए संस्करण संख्या भी प्रदान करनी चाहिए, और यदि संभव हो तो सेटअप पर आवश्यक जानकारी भी।

यदि आप R का उपयोग R स्टूडियो में कर रहे हैं, तो rstudioapi::versionInfo()अपने RStudio संस्करण की रिपोर्ट करने में मददगार हो सकता है।

यदि आपको किसी विशिष्ट पैकेज से कोई समस्या है, तो आप आउटपुट का पैकेज देकर पैकेज का संस्करण प्रदान करना चाहते हैं packageVersion("name of the package")


1 नोट:set.seed() R> 3.6.0 और पिछले संस्करणों के बीच अंतर का आउटपुट । निर्दिष्ट करें कि आपने किस R संस्करण का उपयोग रैंडम प्रक्रिया के लिए किया था, और यदि पुराने प्रश्नों का अनुसरण करते हुए आपको थोड़ा भिन्न परिणाम मिले तो आश्चर्यचकित न हों। इस तरह के मामलों में समान परिणाम प्राप्त करने के लिए, आप RNGversion()-function से पहले set.seed()(उदाहरण :) का उपयोग कर सकते हैं RNGversion("3.5.2")


6
dputयदि डेटाफ़्रेम बहुत बड़ा है और डेटाफ़्रेम के मध्य में समस्या उत्पन्न होती है, तो आप कैसे उपयोग करते हैं ? क्या dputडेटा के मध्य-खंड को पुन: पेश करने के लिए उपयोग करने का एक तरीका है , पंक्तियों को 70 के माध्यम से 60 कहते हैं?
BgnR

27
@ BgnR आप डेटा फ़्रेम का हिस्सा सूचकांकों का उपयोग करके निकाल सकते हैं, जैसे: tmp <- mydf[50:70,]इसके बाद dput(mydf)। यदि डेटा फ़्रेम वास्तव में बड़ा है, तो समस्या को अलग करने का प्रयास करें और समस्या का कारण बनने वाली कुछ पंक्तियों को सबमिट करें।
जोरिस मेय्स

4
@JorisMeys: क्या डेटा को बताने headया dputN को स्तर तक ले जाने के लिए एक तरीका है ? मैं प्रतिलिपि प्रस्तुत करने योग्य उदाहरण के साथ आने की कोशिश कर रहा हूं और मेरा डेटा डेटा फ़्रेम की एक सूची है। इसलिए, dput(head(myDataObj))यह पर्याप्त नहीं लगता है, क्योंकि यह 14MB आकार का आउटपुट फ़ाइल बनाता है।
असेम्बली ब्लेक ऑक

5
@JorisMeys: जस्ट एफवाईआई - एक अलग प्रश्न के रूप में ऊपर टिप्पणी में पोस्ट किया गया सवाल: stackoverflow.com/questions/25127026/…
असेम्बली ब्लेक ऑल

4
@Konrad सबसे अच्छी चीज़ जो आप कर सकते हैं, वह फ़ाइल से लिंक है और उस फ़ाइल में पढ़ने के लिए न्यूनतम कमांड दें। इससे डोप के आउटपुट को कॉपी-पेस्ट करने से कम परेशानी होगी) (:)
जॉरिस मेय्स

589

(यहाँ मेरी सलाह है कि कैसे एक प्रतिलिपि प्रस्तुत करने योग्य उदाहरण लिखने के लिए । मैंने इसे छोटा लेकिन मीठा बनाने की कोशिश की है)

कैसे एक प्रतिलिपि प्रस्तुत करने योग्य उदाहरण लिखने के लिए।

यदि आप एक प्रतिलिपि प्रस्तुत करने योग्य उदाहरण प्रदान करते हैं, तो आपको अपनी आर समस्या के साथ अच्छी मदद मिलने की संभावना है। एक प्रतिलिपि प्रस्तुत करने योग्य उदाहरण किसी और को आर कोड को कॉपी और पेस्ट करके आपकी समस्या को फिर से बनाने की अनुमति देता है।

आपके उदाहरण के लिए प्रतिलिपि प्रस्तुत करने योग्य बनाने के लिए आपको चार चीजों की आवश्यकता है: आवश्यक पैकेज, डेटा, कोड और आपके आर पर्यावरण का विवरण।

  • पैकेज को स्क्रिप्ट के शीर्ष पर लोड किया जाना चाहिए, इसलिए यह देखना आसान है कि किन लोगों को उदाहरण की आवश्यकता है।

  • ईमेल या स्टैक ओवरफ्लो प्रश्न में डेटा शामिल करने का सबसे आसान तरीका है dput()कि आर कोड को फिर से बनाने के लिए इसका उपयोग किया जाए। उदाहरण के लिए, mtcarsडेटासेट को R में फिर से बनाने के लिए , मैं निम्न चरणों का पालन करूँगा:

    1. dput(mtcars)आर में चला
    2. आउटपुट की प्रतिलिपि बनाएँ
    3. मेरी प्रतिलिपि-योग्य स्क्रिप्ट में, mtcars <-फिर पेस्ट करें।
  • यह सुनिश्चित करने में थोड़ा समय व्यतीत करें कि आपका कोड दूसरों के लिए पढ़ना आसान है:

    • सुनिश्चित करें कि आपने रिक्त स्थान का उपयोग किया है और आपके चर नाम संक्षिप्त हैं, लेकिन जानकारीपूर्ण हैं

    • यह इंगित करने के लिए टिप्पणियों का उपयोग करें कि आपकी समस्या कहां है

    • समस्या से संबंधित हर चीज को दूर करने की पूरी कोशिश करें।
      आपका कोड जितना छोटा होगा, समझने में उतना आसान होगा।

  • sessionInfo()अपने कोड में एक टिप्पणी के आउटपुट को शामिल करें । यह आपके R वातावरण को सारांशित करता है और यह जांचना आसान बनाता है कि क्या आप आउट-ऑफ-डेट पैकेज का उपयोग कर रहे हैं।

आप देख सकते हैं कि आपने वास्तव में एक नया आर सत्र शुरू करके और अपनी स्क्रिप्ट को चिपकाकर एक प्रतिलिपि प्रस्तुत करने योग्य उदाहरण बनाया है।

ईमेल में अपना सभी कोड डालने से पहले, इसे जिस्ट गीथब पर रखने पर विचार करें । यह आपके कोड को अच्छा सिंटैक्स हाइलाइटिंग देगा, और आपको ईमेल सिस्टम द्वारा मंगाई गई किसी भी चीज़ के बारे में चिंता करने की ज़रूरत नहीं है।


24
reprexमें tidyverse: कम से कम, प्रतिलिपि प्रस्तुत करने योग्य उदाहरण के उत्पादन के लिए एक अच्छा पैकेज है github.com/tidyverse/reprex
mt1022

19
मैं नियमित रूप से उनमें कोड के साथ ईमेल प्राप्त करता हूं। मैं भी संलग्न शब्द दस्तावेजों के साथ ईमेल प्राप्त करता हूं जिसमें कोड होते हैं। कभी-कभी मुझे संलग्न शब्द दस्तावेजों के साथ ईमेल भी मिलते हैं जिनमें कोड के SCREENSHOTS होते हैं।
हैडली

304

व्यक्तिगत रूप से, मैं "एक" लाइनर्स पसंद करता हूं। रेखाओं के साथ कुछ:

my.df <- data.frame(col1 = sample(c(1,2), 10, replace = TRUE),
        col2 = as.factor(sample(10)), col3 = letters[1:10],
        col4 = sample(c(TRUE, FALSE), 10, replace = TRUE))
my.list <- list(list1 = my.df, list2 = my.df[3], list3 = letters)

डेटा संरचना को लेखक की समस्या के विचार की नकल करनी चाहिए न कि सटीक शब्दशः संरचना की। मैं वास्तव में इसकी सराहना करता हूं जब चर मेरे स्वयं के चर या भगवान को मना नहीं करते हैं, कार्य (जैसे df)।

वैकल्पिक रूप से, कोई कुछ कोनों को काट सकता है और पहले से मौजूद डेटा सेट को इंगित कर सकता है, जैसे कुछ:

library(vegan)
data(varespec)
ord <- metaMDS(varespec)

आपके द्वारा उपयोग किए जा रहे किसी विशेष पैकेज का उल्लेख करना न भूलें।

यदि आप बड़ी वस्तुओं पर कुछ प्रदर्शित करने की कोशिश कर रहे हैं, तो आप कोशिश कर सकते हैं

my.df2 <- data.frame(a = sample(10e6), b = sample(letters, 10e6, replace = TRUE))

यदि आप rasterपैकेज के माध्यम से स्थानिक डेटा के साथ काम कर रहे हैं , तो आप कुछ यादृच्छिक डेटा उत्पन्न कर सकते हैं। पैकेज विगनेट में बहुत सारे उदाहरण मिल सकते हैं, लेकिन यहां एक छोटी सी डली है।

library(raster)
r1 <- r2 <- r3 <- raster(nrow=10, ncol=10)
values(r1) <- runif(ncell(r1))
values(r2) <- runif(ncell(r2))
values(r3) <- runif(ncell(r3))
s <- stack(r1, r2, r3)

यदि आपको कुछ स्थानिक वस्तु की आवश्यकता है जैसा कि कार्यान्वित किया गया है sp, तो आप "स्थानिक" पैकेजों में बाहरी फ़ाइलों (जैसे ESRI शेपफाइल) के माध्यम से कुछ डेटासेट प्राप्त कर सकते हैं (कार्य दृश्य में स्थानिक दृश्य देखें)।

library(rgdal)
ogrDrivers()
dsn <- system.file("vectors", package = "rgdal")[1]
ogrListLayers(dsn)
ogrInfo(dsn=dsn, layer="cities")
cities <- readOGR(dsn=dsn, layer="cities")

1
IMHO, का उपयोग करते समय sampleया runifइसके प्रति विवेकपूर्ण है set.seed। कम से कम, यह सुझाव मुझे प्राप्त हुआ है जब नमूना या यादृच्छिक संख्या पीढ़ी पर रिले करने वाले उदाहरणों का उत्पादन करते हैं।
कोनराड

1
@ कोनराड मैं सहमत हूं, लेकिन यह निर्भर हो सकता है। यदि आप कुछ संख्याओं को उत्पन्न करने की कोशिश कर रहे हैं तो एक बीज की आवश्यकता नहीं हो सकती है, लेकिन यदि आप कुछ विशिष्ट को समझने की कोशिश कर रहे हैं जहाँ निश्चित संख्याओं की आवश्यकता है, तो एक बीज अनिवार्य होगा।
रोमन लुसट्रिक

1
यह हमेशा एक बीज imo के साथ बेहतर होता है, यह अपेक्षित आउटपुट के स्वयं के समाधान की तुलना करना आसान बनाता है, अपने बीच के समाधान की तुलना करता है, और इस तरह से उपयोगकर्ताओं को पता नहीं है (और पता करने की आवश्यकता नहीं है) जैसे कार्य भ्रमित नहीं होते हैं runifया sampleनहीं करते हैं कि वे एक ही डेटा प्राप्त नहीं कर सकते।
मूडी_मडस्किपर

2
@ माइक ने आप को हमेप पैकेज में देखा है ?
रोमन लुसट्रिक

2
@ मिकी पैकेज टाइगरिस ने जनगणना ब्यूरो से कई प्रकार के स्वरूपों में आकार
कैमिली

277

इस पोस्ट से प्रेरित होकर, मैं अब
reproduce(<mydata>)स्टैकऑवरफ्लो में पोस्ट करने की आवश्यकता होने पर एक उपयोगी फ़ंक्शन का उपयोग करता हूं।


त्वरित निर्देश

यदि myDataआपके ऑब्जेक्ट का नाम पुन: उत्पन्न करने के लिए है, तो R में निम्न को चलाएँ:

install.packages("devtools")
library(devtools)
source_url("https://raw.github.com/rsaporta/pubR/gitbranch/reproduce.R")

reproduce(myData)

विवरण:

यह फ़ंक्शन dputनिम्नलिखित के लिए एक बुद्धिमान आवरण है :

  • स्वचालित रूप से एक बड़े डेटा सेट का नमूना (आकार और वर्ग के आधार पर। नमूना आकार समायोजित किया जा सकता है)
  • एक dputआउटपुट बनाता है
  • आपको यह निर्दिष्ट करने की अनुमति देता है कि कौन सा कॉलम निर्यात करना है
  • इसके सामने के हिस्से को जोड़ता है objName <- ...ताकि इसे आसानी से कॉपी किया जा सके + चिपकाया जा सके, लेकिन ...
  • यदि मैक पर काम किया जाता है, तो आउटपुट को स्वचालित रूप से क्लिपबोर्ड पर कॉपी किया जाता है, ताकि आप इसे केवल चला सकें और फिर अपने प्रश्न पर पेस्ट कर सकें।

स्रोत यहां उपलब्ध है:


उदाहरण:

# sample data
DF <- data.frame(id=rep(LETTERS, each=4)[1:100], replicate(100, sample(1001, 100)), Class=sample(c("Yes", "No"), 100, TRUE))

DF 100 x 102 के बारे में है। मैं 10 पंक्तियों और कुछ विशिष्ट स्तंभों का नमूना लेना चाहता हूं

reproduce(DF, cols=c("id", "X1", "X73", "Class"))  # I could also specify the column number. 

निम्नलिखित आउटपुट देता है:

This is what the sample looks like: 

    id  X1 X73 Class
1    A 266 960   Yes
2    A 373 315    No            Notice the selection split 
3    A 573 208    No           (which can be turned off)
4    A 907 850   Yes
5    B 202  46   Yes         
6    B 895 969   Yes   <~~~ 70 % of selection is from the top rows
7    B 940 928    No
98   Y 371 171   Yes          
99   Y 733 364   Yes   <~~~ 30 % of selection is from the bottom rows.  
100  Y 546 641    No        


    ==X==============================================================X==
         Copy+Paste this part. (If on a Mac, it is already copied!)
    ==X==============================================================X==

 DF <- structure(list(id = structure(c(1L, 1L, 1L, 1L, 2L, 2L, 2L, 25L, 25L, 25L), .Label = c("A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y"), class = "factor"), X1 = c(266L, 373L, 573L, 907L, 202L, 895L, 940L, 371L, 733L, 546L), X73 = c(960L, 315L, 208L, 850L, 46L, 969L, 928L, 171L, 364L, 641L), Class = structure(c(2L, 1L, 1L, 2L, 2L, 2L, 1L, 2L, 2L, 1L), .Label = c("No", "Yes"), class = "factor")), .Names = c("id", "X1", "X73", "Class"), class = "data.frame", row.names = c(1L, 2L, 3L, 4L, 5L, 6L, 7L, 98L, 99L, 100L)) 

    ==X==============================================================X==

सूचना यह भी है कि आउटपुट की संपूर्णता एक अच्छी एकल, लंबी लाइन में है, न कि कटा हुआ लाइनों का एक लंबा पैराग्राफ। इससे SO प्रश्न पदों पर पढ़ना आसान हो जाता है और कॉपी पेस्ट करना भी आसान हो जाता है।


अद्यतन 2013 अक्टूबर:

अब आप निर्दिष्ट कर सकते हैं कि टेक्स्ट आउटपुट की कितनी लाइनें लगेंगी (यानी, आप StackOverflow में क्या पेस्ट करेंगे)। इसके लिए lines.out=nतर्क का उपयोग करें। उदाहरण:

reproduce(DF, cols=c(1:3, 17, 23), lines.out=7) पैदावार:

    ==X==============================================================X==
         Copy+Paste this part. (If on a Mac, it is already copied!)
    ==X==============================================================X==

 DF <- structure(list(id = structure(c(1L, 1L, 1L, 1L, 2L, 2L, 2L, 25L,25L, 25L), .Label
      = c("A", "B", "C", "D", "E", "F", "G", "H","I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U","V", "W", "X", "Y"), class = "factor"),
      X1 = c(809L, 81L, 862L,747L, 224L, 721L, 310L, 53L, 853L, 642L),
      X2 = c(926L, 409L,825L, 702L, 803L, 63L, 319L, 941L, 598L, 830L),
      X16 = c(447L,164L, 8L, 775L, 471L, 196L, 30L, 420L, 47L, 327L),
      X22 = c(335L,164L, 503L, 407L, 662L, 139L, 111L, 721L, 340L, 178L)), .Names = c("id","X1",
      "X2", "X16", "X22"), class = "data.frame", row.names = c(1L,2L, 3L, 4L, 5L, 6L, 7L, 98L, 99L, 100L))

    ==X==============================================================X==

196

यहाँ एक अच्छा मार्गदर्शक है

सबसे महत्वपूर्ण बिंदु यह है: बस यह सुनिश्चित करें कि आप एक छोटा सा कोड बनाते हैं जिसे हम यह देखने के लिए चला सकते हैं कि समस्या क्या है । इसके लिए एक उपयोगी कार्य है dput(), लेकिन यदि आपके पास बहुत बड़ा डेटा है, तो आप एक छोटा सा नमूना डेटासेट बनाना चाहते हैं या केवल पहले 10 लाइनों का उपयोग कर सकते हैं।

संपादित करें:

यह भी सुनिश्चित करें कि आपने पहचान की है कि समस्या स्वयं कहाँ है। उदाहरण में "ऑन लाइन 200 में कोई त्रुटि है" के साथ एक संपूर्ण आर स्क्रिप्ट नहीं होना चाहिए। यदि आप R (I love browser()) और Google में डिबगिंग टूल का उपयोग करते हैं, तो आपको वास्तव में यह पहचानने में सक्षम होना चाहिए कि समस्या कहाँ है और एक तुच्छ उदाहरण को पुन: उत्पन्न करता है जिसमें वही बात गलत हो जाती है।


165

आर-हेल्प मेलिंग सूची में एक पोस्टिंग गाइड होता है जो डेटा बनाने के उदाहरण सहित प्रश्न पूछने और जवाब देने दोनों को कवर करता है:

उदाहरण: कभी-कभी यह एक छोटा उदाहरण प्रदान करने में मदद करता है जिसे कोई वास्तव में चला सकता है। उदाहरण के लिए:

यदि मेरे पास मैट्रिक्स x है जो निम्नानुसार है:

  > x <- matrix(1:8, nrow=4, ncol=2,
                dimnames=list(c("A","B","C","D"), c("x","y"))
  > x
    x y
  A 1 5
  B 2 6
  C 3 7
  D 4 8
  >

मैं इसे 8 पंक्तियों के साथ एक डेटाफ्रेम में कैसे बदल सकता हूं, और 'पंक्ति', 'कॉल' और 'वैल्यू' नाम के तीन कॉलम, जिनका आयाम नाम 'पंक्ति' और 'कॉल' के मान हैं, जैसे:

  > x.df
     row col value
  1    A   x      1

...
(जिसका उत्तर हो सकता है:

  > x.df <- reshape(data.frame(row=rownames(x), x), direction="long",
                    varying=list(colnames(x)), times=colnames(x),
                    v.names="value", timevar="col", idvar="row")

)

छोटा शब्द विशेष रूप से महत्वपूर्ण है। आपको एक न्यूनतम प्रजनन योग्य उदाहरण के लिए लक्ष्य होना चाहिए , जिसका अर्थ है कि समस्या को समझाने के लिए डेटा और कोड जितना संभव हो उतना सरल होना चाहिए।

संपादित करें: सुंदर कोड बदसूरत कोड की तुलना में पढ़ने में आसान है। एक शैली गाइड का उपयोग करें ।


164

चूंकि R.2.14 (मुझे लगता है) आप सीधे अपने डेटा पाठ प्रतिनिधित्व को फ़ीड कर सकते हैं read.table:

 df <- read.table(header=TRUE, 
  text="Sepal.Length Sepal.Width Petal.Length Petal.Width Species
1          5.1         3.5          1.4         0.2  setosa
2          4.9         3.0          1.4         0.2  setosa
3          4.7         3.2          1.3         0.2  setosa
4          4.6         3.1          1.5         0.2  setosa
5          5.0         3.6          1.4         0.2  setosa
6          5.4         3.9          1.7         0.4  setosa
") 

3
@ sebastian- सी कैसे प्रजनन योग्य उदाहरण बनाने के लिए अच्छा है ?? :)
टीएमएस

@ टीएमएस ने इसे गंभीरता से सोचा, अगर पूछने वाले ने डेटा की आपूर्ति की है और समस्या छोटी है (लेकिन कुछ समाधान हो सकते हैं), तो यह तेज़ हो सकता है और आप अभी भी सभी चरणों का पालन कर सकते हैं।
सेबस्टियन-सी

146

कभी-कभी समस्या वास्तव में डेटा के एक छोटे से टुकड़े के साथ प्रतिलिपि प्रस्तुत करने योग्य नहीं होती है, चाहे आप कितना भी कठिन प्रयास करें, और सिंथेटिक डेटा के साथ नहीं होता है (हालांकि यह दिखाने के लिए उपयोगी है कि आपने सिंथेटिक डेटा सेट कैसे बनाए जो समस्या को पुन: उत्पन्न करें, क्योंकि यह कुछ परिकल्पनाओं को पूरा करता है)।

  • कहीं वेब पर डेटा पोस्ट करना और एक URL प्रदान करना आवश्यक हो सकता है।
  • यदि डेटा बड़े पैमाने पर जनता के लिए जारी नहीं किया जा सकता है, लेकिन सभी पर साझा किया जा सकता है, तो आप इसे इच्छुक पार्टियों को ई-मेल करने की पेशकश करने में सक्षम हो सकते हैं (हालांकि यह उन लोगों की संख्या में कटौती करेगा जो काम करने के लिए परेशान होंगे। इस पर)।
  • मैंने वास्तव में ऐसा नहीं किया है, क्योंकि जो लोग अपने डेटा को जारी नहीं कर सकते हैं वे इसे किसी भी रूप में जारी करने के बारे में संवेदनशील हैं, लेकिन यह प्रशंसनीय लगेगा कि कुछ मामलों में कोई अभी भी डेटा पोस्ट कर सकता है अगर यह पर्याप्त रूप से अज्ञात / तले हुए / थोड़े दूषित थे किसी तरह।

यदि आप इनमें से कुछ भी नहीं कर सकते हैं, तो आपको शायद अपनी समस्या को हल करने के लिए एक सलाहकार को नियुक्त करना होगा ...

संपादित करें : गुमनामी / स्क्रैचिंग के लिए दो उपयोगी SO प्रश्न:


1
सिंथेटिक डेटा सेट के उत्पादन के लिए, इस प्रश्न के उत्तर उपयोगी उदाहरण देते हैं, जिसमें fitdistrऔर के अनुप्रयोग शामिल हैं fitdistrplus
इटरेटर

137

अब तक के उत्तर स्पष्ट रूप से प्रतिलिपि प्रस्तुत करने योग्य भाग के लिए बहुत अच्छे हैं। यह केवल यह स्पष्ट करना है कि एक प्रतिलिपि प्रस्तुत करने योग्य उदाहरण एक प्रश्न का एकमात्र घटक नहीं हो सकता है और नहीं होना चाहिए। यह समझने की भूल न करें कि आप क्या चाहते हैं कि वह आपकी तरह दिखे और आपकी समस्या का समाधान हो, न कि आपने अभी तक वहां पहुंचने का प्रयास किया है। कोड पर्याप्त नहीं है; आपको शब्दों की भी आवश्यकता है।

यहाँ क्या करने से बचने के लिए एक वास्तविक उदाहरण है (एक वास्तविक उदाहरण से तैयार, निर्दोषों की रक्षा के लिए नाम बदल गए):


निम्नलिखित नमूना डेटा और फ़ंक्शन का एक हिस्सा है जिससे मुझे परेशानी है।

code
code
code
code
code (40 or so lines of it)

इसे कैसे प्राप्त किया जा सकता है ?



124

मेरे पास R उदाहरण बनाने के लिए एक बहुत ही आसान और कुशल तरीका है जिसका उल्लेख ऊपर नहीं किया गया है। आप सबसे पहले अपनी संरचना को परिभाषित कर सकते हैं। उदाहरण के लिए,

mydata <- data.frame(a=character(0), b=numeric(0),  c=numeric(0), d=numeric(0))

>fix(mydata)

जब आप 'फिक्स' कमांड निष्पादित करते हैं, तो आपको यह पॉप-अप बॉक्स मिलेगा

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


18
... फिरdput(mydata)
GSee

आपका लुक क्या है? पूरा जवाब देना अच्छा होगा। आदि एक डेटा बनाते हैं जिसे आप सीधे लूप की तरह कर सकते हैं for (d in data) {...}
लेओ लेपोल्ड हर्ट्ज़ '

119

dputअपने डेटा को जल्दी से बनाने के लिए आप अपने क्लिपबोर्ड पर डेटा (केवल एक टुकड़ा) कॉपी कर सकते हैं और निम्नलिखित को आर में चला सकते हैं:

Excel में डेटा के लिए:

dput(read.table("clipboard",sep="\t",header=TRUE))

txt फ़ाइल में डेटा के लिए:

dput(read.table("clipboard",sep="",header=TRUE))

sepयदि आवश्यक हो तो आप बाद में बदल सकते हैं । यह तभी काम करेगा जब आपका डेटा पाठ्यक्रम के क्लिपबोर्ड में होगा।


116

दिशानिर्देश:


आपके प्रश्नों को तैयार करने में आपका मुख्य उद्देश्य यह होना चाहिए कि पाठकों को उनकी प्रणालियों पर आपकी समस्या को समझने और पुन: पेश करने के लिए जितना संभव हो सके उतना आसान बनाया जाए। ऐसा करने के लिए:

  1. इनपुट डेटा प्रदान करें
  2. अपेक्षित उत्पादन प्रदान करें
  3. अपनी समस्या को स्पष्ट रूप से समझाएं
    • यदि आपके पास पाठ + कोड की 20 से अधिक पंक्तियाँ हैं, तो आप संभवतः वापस जा सकते हैं और सरल कर सकते हैं
    • समस्या / त्रुटि को संरक्षित करते हुए अपने कोड को यथासंभव सरल बनाएं

यह कुछ काम लेता है, लेकिन एक निष्पक्ष व्यापार बंद जैसा लगता है क्योंकि आप दूसरों से आपके लिए काम करने के लिए कह रहे हैं।

डेटा प्रदान करना:


अंतर्निहित डेटा सेट

अब तक का सबसे अच्छा विकल्प अंतर्निहित डेटासेट पर भरोसा करना है। इससे दूसरों को आपकी समस्या पर काम करने में बहुत आसानी होती है। data()R प्रांप्ट पर टाइप करके देखें कि आपके पास कौन सा डेटा उपलब्ध है। कुछ क्लासिक उदाहरण:

  • iris
  • mtcars
  • ggplot2::diamonds (बाहरी पैकेज, लेकिन लगभग सभी के पास है)

अपनी समस्या के लिए उपयुक्त डेटा सेट कैसे खोजें, इसके लिए यह SO QA देखें ।

यदि आप बिल्ट-इन डेटासेट्स का उपयोग करने के लिए अपनी समस्या को फिर से समझने में सक्षम हैं, तो आपको अच्छे उत्तर (और अपवोट्स) मिलने की अधिक संभावना है।

स्वयं निर्मित डेटा

यदि आपकी समस्या एक प्रकार के डेटा के लिए बहुत विशिष्ट है, जो मौजूदा डेटा सेटों में प्रतिनिधित्व नहीं करता है, तो आर कोड प्रदान करें जो सबसे छोटी संभव डेटासेट उत्पन्न करता है जो आपकी समस्या स्वयं प्रकट होती है। उदाहरण के लिए

set.seed(1)  # important to make random data reproducible
myData <- data.frame(a=sample(letters[1:5], 20, rep=T), b=runif(20))

अब कोई मेरे प्रश्न का उत्तर देने की कोशिश कर रहा है, उन दो लाइनों को कॉपी / पेस्ट कर सकता है और समस्या पर तुरंत काम करना शुरू कर सकता है।

dput

एक के रूप में अंतिम उपाय है, तो आप उपयोग कर सकते हैं dputआर कोड (जैसे करने के लिए एक डेटा वस्तु को बदलने के लिए dput(myData))। मैं एक "अंतिम उपाय" के रूप में कहता हूं क्योंकि इसका आउटपुट dputअक्सर बहुत ही अस्पष्ट होता है, जो कॉपी-पेस्ट से परेशान होता है, और आपके शेष प्रश्न को अस्पष्ट करता है।

अपेक्षित आउटपुट प्रदान करें:


किसी ने एक बार कहा था:

अपेक्षित आउटपुट की एक तस्वीर 1000 शब्दों के लायक है

- बहुत बुद्धिमान व्यक्ति

यदि आप कुछ ऐसा जोड़ सकते हैं जैसे "मुझे यह परिणाम मिलने की उम्मीद है":

   cyl   mean.hp
1:   6 122.28571
2:   4  82.63636
3:   8 209.21429

आपके प्रश्न के लिए, लोगों को यह समझने की अधिक संभावना है कि आप क्या करने की कोशिश कर रहे हैं। यदि आपका अपेक्षित परिणाम बड़ा है और बहुत ही कम है, तो आपने अपनी समस्या को सरल बनाने के बारे में पर्याप्त नहीं सोचा है (आगे देखें)।

अपनी समस्या को स्पष्ट रूप से समझाइए


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

यहाँ अच्छे सवालों के कुछ उदाहरण दिए गए हैं:

दोनों मामलों में, उपयोगकर्ता की समस्याएं लगभग निश्चित रूप से उन सरल उदाहरणों के साथ नहीं हैं जो वे प्रदान करते हैं। बल्कि उन्होंने अपनी समस्या की प्रकृति को समाप्त कर दिया और इसे अपने प्रश्न पूछने के लिए एक सरल डेटा सेट पर लागू किया।

फिर भी इस सवाल का एक और जवाब क्यों?


यह उत्तर इस बात पर केंद्रित है कि मुझे क्या लगता है कि यह सबसे अच्छा अभ्यास है: अंतर्निहित डेटा सेट का उपयोग करें और यह प्रदान करें कि आप न्यूनतम रूप में क्या उम्मीद करते हैं। सबसे प्रमुख उत्तर अन्य पहलुओं पर ध्यान केंद्रित करते हैं। मैं इस उत्तर की अपेक्षा किसी प्रमुखता से नहीं करता; यह पूरी तरह से यहाँ है ताकि मैं इसे नौसिखिया सवालों के लिए टिप्पणियों में लिंक कर सकूं।


113

मदद पाने के लिए Reproducible कोड प्रमुख है। हालांकि, कई उपयोगकर्ता हैं जो अपने डेटा का एक हिस्सा भी चिपकाने में संदेह कर सकते हैं। उदाहरण के लिए, वे संवेदनशील डेटा या एक शोध पत्र में उपयोग करने के लिए एकत्र किए गए मूल डेटा पर काम कर सकते हैं। किसी भी कारण से, मैंने सोचा कि इसे सार्वजनिक रूप से चिपकाने से पहले अपने डेटा को "ख़राब" करने के लिए एक आसान कार्य करना अच्छा होगा। anonymizeपैकेज से समारोह SciencesPoबहुत मूर्खतापूर्ण है, लेकिन मेरे लिए यह काम करता है के साथ अच्छी तरह dputकार्य करते हैं।

install.packages("SciencesPo")

dt <- data.frame(
    Z = sample(LETTERS,10),
    X = sample(1:10),
    Y = sample(c("yes", "no"), 10, replace = TRUE)
)

> dt
   Z  X   Y
1  D  8  no
2  T  1 yes
3  J  7  no
4  K  6  no
5  U  2  no
6  A 10 yes
7  Y  5  no
8  M  9 yes
9  X  4 yes
10 Z  3  no

फिर मैं इसे गुमनाम करता हूं:

> anonymize(dt)
     Z    X  Y
1   b2  2.5 c1
2   b6 -4.5 c2
3   b3  1.5 c1
4   b4  0.5 c1
5   b7 -3.5 c1
6   b1  4.5 c2
7   b9 -0.5 c1
8   b5  3.5 c2
9   b8 -1.5 c2
10 b10 -2.5 c1

गुमनामी और विवाद आदेश लागू करने से पहले पूरे डेटा के बजाय कुछ चर का नमूना लेना चाह सकते हैं।

    # sample two variables without replacement
> anonymize(sample.df(dt,5,vars=c("Y","X")))
   Y    X
1 a1 -0.4
2 a1  0.6
3 a2 -2.4
4 a1 -1.4
5 a2  3.6

102

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

जैसे,

data(mtcars)

और फिर समस्या है

names(mtcars)
your problem demostrated on the mtcars data set

13
कई अंतर्निहित डेटा सेट (लोकप्रिय mtcarsऔर irisडेटासेट की तरह ) को वास्तव में dataकॉल करने की आवश्यकता नहीं होती है।
ग्रेगर थॉमस

92

यदि आपके पास बड़े डेटासेट हैं, जिन्हें आसानी से उपयोग करने वाली स्क्रिप्ट में नहीं रखा जा सकता है dput(), तो अपने डेटा को पास्टबिन में पोस्ट करें और उनका उपयोग करके लोड करें read.table:

d <- read.table("http://pastebin.com/raw.php?i=m1ZJuKLH")

@ हेनरिक से प्रेरित ।


90

मैं जल्दी से प्रतिलिपि प्रस्तुत करने योग्य डेटा साझा करने के लिए इस आवश्यकता को पूरा करने के लिए वेकफील्ड पैकेज विकसित कर रहा हूं , कभी-कभी dputछोटे डेटा सेटों के लिए ठीक काम करता है लेकिन हम जिन समस्याओं से निपटते हैं वे बहुत बड़े होते हैं, इस तरह के बड़े डेटा सेट को साझा करना dputअव्यावहारिक है।

के बारे में:

वेकफील्ड उपयोगकर्ता को डेटा पुन: पेश करने के लिए न्यूनतम कोड साझा करने की अनुमति देता है। उपयोगकर्ता सेटn(पंक्तियों की संख्या) और किसी भी पूर्व निर्धारित चर कार्यों को निर्दिष्ट करता है (वर्तमान में 70 हैं) यदि डेटा (लिंग, आयु, आय आदि जैसी चीजें) वास्तविक की नकल करता है।

स्थापना:

वर्तमान में (2015-06-11), वेकफील्ड गीथहब पैकेज है, लेकिन यूनिट परीक्षणों के लिखे जाने के बाद अंततः सीआरएएन में जाएगा। जल्दी से स्थापित करने के लिए, उपयोग करें:

if (!require("pacman")) install.packages("pacman")
pacman::p_load_gh("trinker/wakefield")

उदाहरण:

यहाँ एक उदाहरण है:

r_data_frame(
    n = 500,
    id,
    race,
    age,
    sex,
    hour,
    iq,
    height,
    died
)

यह उत्पादन करता है:

    ID  Race Age    Sex     Hour  IQ Height  Died
1  001 White  33   Male 00:00:00 104     74  TRUE
2  002 White  24   Male 00:00:00  78     69 FALSE
3  003 Asian  34 Female 00:00:00 113     66  TRUE
4  004 White  22   Male 00:00:00 124     73  TRUE
5  005 White  25 Female 00:00:00  95     72  TRUE
6  006 White  26 Female 00:00:00 104     69  TRUE
7  007 Black  30 Female 00:00:00 111     71 FALSE
8  008 Black  29 Female 00:00:00 100     64  TRUE
9  009 Asian  25   Male 00:30:00 106     70 FALSE
10 010 White  27   Male 00:30:00 121     68 FALSE
.. ...   ... ...    ...      ... ...    ...   ...

72

यदि factorआपके डेटा में एक या एक से अधिक वैरिएबल हैं, जिन्हें आप प्रतिलिपि बनाना चाहते हैं , तो इसे dput(head(mydata))जोड़ने droplevelsपर विचार करें , ताकि कम से कम डेटा सेट में मौजूद कारकों के स्तर आपके dputआउटपुट में शामिल न हों , उदाहरण को न्यूनतम करें :

dput(droplevels(head(mydata)))

65

मुझे आश्चर्य है कि अगर एक http://old.r-fiddle.org/ लिंक एक समस्या को साझा करने का एक बहुत साफ तरीका हो सकता है। यह एक विशिष्ट आईडी प्राप्त करता है और कोई भी इसे SO में एम्बेड करने के बारे में सोच सकता है।


47

कृपया अपने कंसोल आउटपुट को इस तरह पेस्ट न करें:

If I have a matrix x as follows:
> x <- matrix(1:8, nrow=4, ncol=2,
            dimnames=list(c("A","B","C","D"), c("x","y")))
> x
  x y
A 1 5
B 2 6
C 3 7
D 4 8
>

How can I turn it into a dataframe with 8 rows, and three
columns named `row`, `col`, and `value`, which have the
dimension names as the values of `row` and `col`, like this:
> x.df
    row col value
1    A   x      1
...
(To which the answer might be:
> x.df <- reshape(data.frame(row=rownames(x), x), direction="long",
+                varying=list(colnames(x)), times=colnames(x),
+                v.names="value", timevar="col", idvar="row")
)

हम इसे सीधे कॉपी-पेस्ट नहीं कर सकते।

प्रश्न और उत्तर को ठीक से प्रतिलिपि प्रस्तुत करने योग्य बनाने के लिए, पोस्ट करने से पहले उसे हटाने +और आउटपुट के लिए प्रयास करें >और #इस तरह से टिप्पणी करें:

#If I have a matrix x as follows:
x <- matrix(1:8, nrow=4, ncol=2,
            dimnames=list(c("A","B","C","D"), c("x","y")))
x
#  x y
#A 1 5
#B 2 6
#C 3 7
#D 4 8

# How can I turn it into a dataframe with 8 rows, and three
# columns named `row`, `col`, and `value`, which have the
# dimension names as the values of `row` and `col`, like this:

#x.df
#    row col value
#1    A   x      1
#...
#To which the answer might be:

x.df <- reshape(data.frame(row=rownames(x), x), direction="long",
                varying=list(colnames(x)), times=colnames(x),
                v.names="value", timevar="col", idvar="row")

एक और बात, अगर आपने किसी निश्चित पैकेज से किसी फ़ंक्शन का उपयोग किया है, तो उस लाइब्रेरी का उल्लेख करें।


2
क्या आप इसे हटाते >हैं और #मैन्युअल रूप से जोड़ते हैं या ऐसा करने का कोई स्वचालित तरीका है?
BCArg

3
@BCArg मैं >मैन्युअल रूप से निकालता हूं । लेकिन, इसके अतिरिक्त #, मैं संपादक Ctrl+Shift+Cमें शॉर्टकट का उपयोग करता हूं RStudio
user2100721

33

आप इसे रेप्रेक्स का उपयोग करके कर सकते हैं ।

के रूप में mt1022 उल्लेख किया , "... कम से कम, प्रतिलिपि प्रस्तुत करने योग्य उदाहरण के उत्पादन के लिए अच्छा पैकेज है " reprex " से tidyverse "।

तिद्वारे के अनुसार :

"रेप्रेक्स" का लक्ष्य आपके समस्याग्रस्त कोड को इस तरह से पैकेज करना है ताकि अन्य लोग इसे चला सकें और आपके दर्द को महसूस कर सकें।

एक उदाहरण tidyverse वेब साइट पर दिया गया है ।

library(reprex)
y <- 1:4
mean(y)
reprex() 

मुझे लगता है कि यह एक प्रतिलिपि प्रस्तुत करने योग्य उदाहरण बनाने का सबसे सरल तरीका है।


33

उपरोक्त सभी उत्तरों के अलावा, जो मुझे बहुत दिलचस्प लगा, यह कभी-कभी बहुत आसान हो सकता है क्योंकि यहाँ पर चर्चा की गई है: - कैसे एक न्यूनतम रिपोर्ट बनाने के लिए उदाहरण R के साथ सहायता प्राप्त करें

एक यादृच्छिक वेक्टर बनाने के कई तरीके हैं R में यादृच्छिक मान के साथ 100 नंबर वेक्टर बनाएं 2 दशमलव में यादृच्छिक या आर में यादृच्छिक मैट्रिक्स

mydf1<- matrix(rnorm(20),nrow=20,ncol=5)

ध्यान दें कि कभी-कभी विभिन्न कारणों जैसे आयाम आदि के कारण किसी दिए गए डेटा को साझा करना बहुत मुश्किल होता है। हालांकि, उपरोक्त सभी उत्तर महान और बहुत महत्वपूर्ण हैं, जब कोई प्रतिलिपि प्रस्तुत करने योग्य डेटा उदाहरण बनाना चाहता है। लेकिन ध्यान दें कि एक डेटा को मूल के रूप में प्रतिनिधि बनाने के लिए (यदि ओपी मूल डेटा को साझा नहीं कर सकता है), तो डेटा उदाहरण के साथ कुछ जानकारी जोड़ना अच्छा है (जैसे कि हम डेटा को mydf1 कहते हैं)

class(mydf1)
# this shows the type of the data you have 
dim(mydf1)
# this shows the dimension of your data

इसके अलावा, किसी को डेटा के प्रकार, लंबाई और विशेषताओं को जानना चाहिए जो डेटा संरचनाएं हो सकती हैं

#found based on the following 
typeof(mydf1), what it is.
length(mydf1), how many elements it contains.
attributes(mydf1), additional arbitrary metadata.

#If you cannot share your original data, you can str it and give an idea about the structure of your data
head(str(mydf1))

28

यहाँ मेरे कुछ सुझाव हैं:

  • डिफ़ॉल्ट R डेटासेट का उपयोग करने का प्रयास करें
  • यदि आपके पास अपना स्वयं का डेटासेट है dput, तो उन्हें शामिल करें , ताकि अन्य आपकी अधिक आसानी से मदद कर सकें
  • install.package()जब तक यह वास्तव में आवश्यक नहीं है, तब तक उपयोग न करें , लोग समझेंगे कि क्या आप सिर्फ उपयोग करते हैं requireयाlibrary
  • संक्षिप्त होने का प्रयास करें,

    • कुछ डाटासेट हैं
    • जितना संभव हो उतना उत्पादन का वर्णन करने का प्रयास करें
    • प्रश्न पूछने से पहले इसे स्वयं करें
  • छवि अपलोड करना आसान है, इसलिए यदि आपके पास प्लॉट अपलोड हैं
  • इसके अलावा आपके द्वारा की जाने वाली कोई भी त्रुटि हो सकती है

ये सभी एक प्रतिलिपि प्रस्तुत करने योग्य उदाहरण का हिस्सा हैं।


1
आपने वास्तव में यहां किसी भी पदार्थ को नहीं जोड़ा है। dput()पहले उल्लेख किया गया है, और इसमें से बहुत मानक एसओ दिशानिर्देशों को दोहरा रहे हैं।
रिच स्क्रिप्‍ट

1
मुझे install.packageउदाहरण में शामिल फ़ंक्शन के साथ समस्या हो रही थी जो वास्तव में आवश्यक नहीं है (मेरी राय में)। इसके अलावा, डिफ़ॉल्ट R डेटासेट का उपयोग करने से प्रतिलिपि प्रस्तुत करने योग्य आसान हो जाएगा। एसओ दिशानिर्देशों ने इन विषयों के बारे में विशेष रूप से बात नहीं की है। इसके अलावा, यह मेरी राय देने के लिए था और ये वही हैं जिनका मैंने सबसे अधिक सामना किया है।
हिमालय

18

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

library(testthat)
# code defining x and y
if (y >= 10) {
    expect_equal(x, 1.23)
} else {
    expect_equal(x, 3.21)
}

यह स्पष्ट है कि "मुझे लगता है कि x 10 के बराबर या उससे अधिक y के लिए 1.23 होगा, और 3.21 अन्यथा, लेकिन मुझे न तो परिणाम मिला"। इस मूर्खतापूर्ण उदाहरण में भी, मुझे लगता है कि कोड शब्दों से अधिक स्पष्ट है। का उपयोग करते हुए testthatकोड है, जो समय की बचत होती पर अपने सहायक फोकस की सुविधा देता है, और यह पता करने के लिए वे अपनी समस्या का समाधान कर लिया है उनके लिए एक तरीका प्रदान करता है, इससे पहले कि वे इसे पोस्ट

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.