(Oto moja rada z Jak napisać powtarzalny przykład . Starałam się, żeby było krótko, ale słodko)

Jak napisać powtarzalny przykład.

Najprawdopodobniej otrzymasz dobrą pomoc z problemem R, Jeśli podasz powtarzalny przykład. Powtarzalny przykład pozwala komuś innemu odtworzyć twój problem, kopiując i wklejając kod R.

Są cztery rzeczy, które musisz dołączyć, aby twój przykład był powtarzalny: wymagane pakiety, dane, Kod, i opis Twojego środowiska R.

• Pakiety {[19] } powinny być ładowane u góry skryptu, więc jest to łatwe do zobacz, których potrzebuje przykład.

• Najprostszym sposobem na dołączenie danych do wiadomości e-mail lub pytania o przepełnienie stosu jest użycie dput() do wygenerowania kod R do odtworzenia. Na przykład, aby odtworzyć zbiór danych mtcars W R, Wykonałbym następujące kroki:

  1. Run dput(mtcars) in R
  2. skopiuj wyjście
  3. W mój powtarzalny skrypt, wpisz mtcars <-, a następnie wklej.

• Poświęć trochę czasu, aby twój kod {[19] } był łatwy dla innych powinno być:

  • Upewnij się, że używane spacje i nazwy zmiennych są zwięzłe, ale informacyjna

  • Użyj komentarzy, aby wskazać, gdzie leży twój problem

  • Postaraj się usunąć wszystko, co nie jest związane z problemem.
    Im krótszy kod, tym łatwiej Rozumiem.

• Dołącz wyjście sessionInfo() do komentarza w kodzie. To podsumowuje twój R środowisko i ułatwia sprawdzenie, czy używasz nieaktualnego paczka.

Możesz sprawdzić, czy rzeczywiście zrobiłeś powtarzalny przykład, uruchamiając świeżą sesję R i wklejając skrypt.

Zanim umieścisz cały kod w wiadomości e-mail, rozważ umieszczenie go na GIST github . To da Twój kod ładny podświetlanie składni i nie musisz się martwić, że coś zostanie zniekształcone przez system poczty e-mail.

Osobiście wolę wkładki" jedno". Coś w stylu:

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)

Struktura danych powinna naśladować ideę problemu pisarza, a nie dokładną strukturę. Naprawdę doceniam to, gdy zmienne Nie nadpisują moich własnych zmiennych lub nie daj Boże, funkcji(jak df).

Alternatywnie, można wyciąć kilka narożników i wskazać na wcześniej istniejący zestaw danych, coś w stylu:

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

Nie zapomnij wspomnieć o specjalnych pakietach, którymi możesz być używam.

Jeśli próbujesz zademonstrować coś na większych obiektach, możesz spróbować

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

Jeśli pracujesz z danymi przestrzennymi za pomocą pakietu raster, możesz wygenerować losowe DANE. Wiele przykładów można znaleźć w winiecie pakietu, ale tutaj jest mały samorodek.

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)

Jeśli potrzebujesz jakiegoś obiektu przestrzennego zaimplementowanego w sp, możesz pobrać niektóre zbiory danych za pomocą zewnętrznych plików (takich jak ESRI shapefile) w pakietach "przestrzennych" (zobacz Widok przestrzenny w zadaniu Wyświetleń).

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

Zainspirowany tym samym postem, używam teraz poręcznej funkcji
reproduce(<mydata>) kiedy muszę pisać do StackOverflow.

SZYBKIE INSTRUKCJE

Jeśli myData jest nazwą obiektu do odtworzenia, uruchom następujące polecenie w R:

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

reproduce(myData)

Szczegóły:

Ta funkcja jest inteligentnym opakowaniem do dput i wykonuje następujące czynności:

• automatycznie pobiera duży zestaw danych (w oparciu o rozmiar i klasę. Wielkość próbki można dostosować)
• tworzy dput wyjście
• pozwala określić które kolumny mają zostać wyeksportowane
• dołącza do przodu objName <- ... tak, że można go łatwo skopiować+wkleić, ale...
• jeśli pracujesz na komputerze mac, wynik jest automatycznie kopiowany do schowka, dzięki czemu można go po prostu uruchomić, a następnie wkleić do swojego pytania.

Źródło jest dostępne tutaj:

• Github-pubR / reproduce.R

Przykład:

# 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 jest o 100 x 102. Chcę wypróbować 10 wierszy i kilka konkretnych kolumn

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

Daje następujące wyjście:

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==

Zauważ również, że całość wyjścia jest w ładnej pojedynczej, długiej linii, a nie wysokim akapicie pociętych linii. Ułatwia to czytanie postów SO questions, a także łatwiejsze kopiowanie + wklejanie.

Aktualizacja Październik 2013:

Możesz teraz określić, ile wierszy tekstu zostanie pobranych (np. co wkleisz do StackOverflow). Użycie lines.out=n argument na to. Przykład:

reproduce(DF, cols=c(1:3, 17, 23), lines.out=7) wydajność:

    ==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==

Oto dobry poradnik:

Http://www.r-bloggers.com/three-tips-for-posting-good-questions-to-r-help-and-stack-overflow/

Ale najważniejsze jest: po prostu upewnij się, że tworzysz mały kawałek kodu, który możemy uruchomić, aby zobaczyć, na czym polega problem. Przydatną funkcją do tego jest dput(), ale jeśli masz bardzo duże dane, możesz chcieć utworzyć mały przykładowy zestaw danych lub użyć tylko pierwszych 10 linii.

EDIT:

Upewnij się również, że zidentyfikowałeś gdzie problemem jest ty. Przykładem nie powinien być cały skrypt R Z "On line 200 there is an error". Jeśli używasz narzędzi debugowania w R (I love browser()) i google powinieneś być w stanie naprawdę zidentyfikować, gdzie jest problem i odtworzyć trywialny przykład, w którym to samo idzie nie tak.

Lista dyskusyjna R-help zawiera przewodnik po publikowaniu , który obejmuje zarówno zadawanie pytań, jak i odpowiadanie na nie, w tym Przykład generowania danych:

Przykłady: czasami pomaga podaj mały przykład, że ktoś może naprawdę biegać. Na przykład:

Jeśli mam macierz x w następujący sposób:

  > 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
  >

Jak mogę przekształcić go w ramkę danych z 8 rzędami i trzema kolumnami o nazwie 'row', ' col ' I 'value', które mają wymiar nazywa się jako wartości ' row 'i ' col', takie jak:

  > x.df
     row col value
  1    A   x      1

...
(Na co odpowiedź może brzmieć:

  > 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")

)

Słowo małe jest szczególnie ważne. Powinieneś dążyć do minimalnego powtarzalnego przykładu, co oznacza, że dane i Kod powinny być tak proste, jak to możliwe, aby wyjaśnić problem.

EDIT: ładny kod jest łatwiejszy do odczytania niż brzydki kod. Użyj style guide .

Od R. 2. 14 (chyba) możesz podawać swoje dane tekstowe bezpośrednio do odczytu.tabela:

df <- read.table(header=T, 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
") 

Czasami problem naprawdę nie jest powtarzalny z mniejszym kawałkiem danych, bez względu na to, jak bardzo się starasz, i nie dzieje się z danymi syntetycznymi (chociaż przydatne jest pokazanie, w jaki sposób wyprodukowałeś syntetyczne zbiory danych, które nie odtworzyły problem, ponieważ wyklucza to pewne hipotezy).

• może być konieczne zamieszczenie danych w Internecie i podanie adresu URL.
• Jeśli dane nie mogą być publicznie udostępniane, ale mogą być w ogóle udostępniane, to być może będziesz mógł zaoferować go zainteresowanym (chociaż zmniejszy to liczbę osób, które będą się nad nim trudzić).
• w rzeczywistości nie widziałem tego zrobić, ponieważ ludzie, którzy nie mogą udostępnić swoje dane są wrażliwe na uwolnienie go w jakiejkolwiek formie, ale wydaje się prawdopodobne, że w niektórych przypadkach można jeszcze opublikować dane, jeśli były wystarczająco zanonimizowane/zaszyfrowane / uszkodzone nieco w jakiś sposób.

Jeśli nie możesz zrobić żadnej z tych rzeczy, prawdopodobnie musisz wynajmij konsultanta, który rozwiąże twój problem ...

Edit : dwa przydatne pytania do anonimizacji/scramblingu:

• Jak stworzyć przykładowy zestaw danych z prywatnych danych (zamieniając nazwy i poziomy zmiennych na uninformative place holders)?
• biorąc pod uwagę zbiór liczb losowych narysowanych z ciągłego rozkładu jednowymiarowego, znajdź rozkład

Odpowiedzi do tej pory są oczywiście świetne dla części odtwarzalności. Chodzi jedynie o wyjaśnienie, że powtarzalny przykład nie może i nie powinien być jedynym składnikiem pytania. Nie zapomnij wyjaśnić, jak chcesz, aby wyglądać i kontury swojego problemu, a nie tylko jak starałeś się tam dotrzeć do tej pory. Kod to za mało; potrzebujesz też słów.

Oto powtarzalny przykład tego, czego unikać (zaczerpnięty z prawdziwego przykładu, nazwy zmienione w celu ochrony innocent): {]}

Poniżej znajdują się przykładowe dane i część funkcji, z którą mam problem.

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

Jak mogę to osiągnąć ?

Aby szybko utworzyć dput swoich danych, możesz po prostu skopiować (fragment) dane do schowka i uruchomić następujące W R:

Dla danych w Excelu:

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

Dla danych w pliku txt:

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

Możesz zmienić sep w tym ostatnim, jeśli to konieczne. Będzie to działać tylko wtedy, gdy Twoje dane znajdują się oczywiście w schowku.

Mam bardzo łatwy i skuteczny sposób, aby zrobić przykład R, który nie został wymieniony powyżej. Najpierw możesz zdefiniować swoją strukturę. Na przykład,

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

>fix(mydata)

Następnie możesz wprowadzić swoje dane ręcznie. Jest to wydajne dla mniejszych przykładów, a nie dużych.

Powtarzalny kod jest kluczem do uzyskania pomocy. Istnieje jednak wielu użytkowników, którzy mogą być sceptyczni wobec wklejania nawet fragmentu swoich danych. Na przykład mogą pracować z danymi wrażliwymi lub na oryginalnych danych zebranych w celu wykorzystania w dokumencie badawczym. Z jakiegokolwiek powodu pomyślałem, że byłoby miło mieć przydatną funkcję do "deformowania" moich danych przed wklejeniem ich publicznie. Funkcja anonymize z pakietu SciencesPo jest bardzo głupia, ale dla mnie działa ładnie z funkcją 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

Potem go anonimizuję:

> 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

Przed zastosowaniem anonimizacji i polecenia dput można również pobrać kilka zmiennych zamiast całych danych.

    # 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

Wytyczne:

Twoim głównym celem w tworzeniu pytań powinno być ułatwienie czytelnikom zrozumienia i odtworzenia Twojego problemu na ich systemach. Aby to zrobić:

1. podaj dane wejściowe
2. dostarczyć oczekiwany wynik
3. zwięźle wyjaśnij swój problem
   • jeśli masz ponad 20 linijek tekstu + kodu, prawdopodobnie możesz wrócić i uprościć
   • uprość kod tak bardzo, jak to możliwe, zachowując problem / błąd

Podanie Danych:

Wbudowane zestawy danych

Najlepszą opcją zdecydowanie jest poleganie na wbudowanych zestawach danych. Ułatwia to innym pracę nad Twoim problemem. Wpisz data() w monicie R, aby zobaczyć, jakie dane są dostępne. Niektóre klasyczne przykłady:

• iris
• mtcars
• ggplot2::diamonds (zewnętrzny pakiet, ale prawie każdy go ma)

Zobacz też SO QA Jak znaleźć zestawy danych odpowiednie dla Twojego problemu.

Jeśli jesteś w stanie przeformułować swój problem, aby użyć wbudowanych zestawów danych, o wiele bardziej prawdopodobne, aby uzyskać dobre odpowiedzi (i głosy).

Dane Generowane Przez Siebie

Jeśli twój problem jest bardzo specyficzny dla typu danych, które nie są reprezentowane w istniejące zbiory danych, następnie podaj kod R, który generuje najmniejszy możliwy zbiór danych, na którym pojawia się problem. Na przykład

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

Teraz ktoś próbuje odpowiedzieć na moje pytanie może skopiować/wkleić te dwie linie i natychmiast rozpocząć pracę nad problemem.

Dput

Jako w ostateczności , możesz użyć dput do przekształcenia obiektu danych w kod R (np. dput(myData)). Mówię jako "ostateczność", ponieważ wyjście dput jest często dość nieporęczny, irytujący do kopiowania-wklejania i zasłania resztę pytania.

Podaj Oczekiwany Wynik:

Ktoś kiedyś powiedział:

Obraz oczekiwanej produkcji jest wart 1000 słów

-- bardzo mądra osoba

Jeśli możesz dodać coś w stylu "spodziewałem się tego wyniku":

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

Na twoje pytanie, ludzie są znacznie bardziej prawdopodobne, aby szybko zrozumieć, co próbujesz zrobić. Jeśli oczekiwany wynik jest duży i nieporęczny, to pewnie nie myślałeś wystarczająco dużo o tym, jak uprościć swój problem(patrz dalej).

Wyjaśnij Swój Problem Zwięźle

Najważniejsze jest, aby uprościć swój problem tak bardzo, jak to możliwe, zanim zadasz pytanie. Ponowne kadrowanie problemu do pracy z wbudowanymi zestawami danych bardzo pomoże w tym zakresie. Często przekonasz się również, że przechodząc przez proces upraszczania, odpowiesz na swój własny problem.

Oto kilka przykłady dobrych pytań:

• z wbudowanym zestawem danych
• z dane generowane przez użytkowników

W obu przypadkach problemy użytkownika są prawie na pewno nie z prostymi przykładami, które dostarczają. Raczej abstrakcyjny charakter ich problemu i stosowane go do prostego zestawu danych, aby zadać swoje pytanie.

Dlaczego Jeszcze Jedna Odpowiedź Na To Pytanie?

Ta odpowiedź skupia się na tym, co moim zdaniem jest najlepszą praktyką: użyj wbudowane zestawy danych i dostarczyć to, czego oczekujesz w wyniku w minimalnej formie. Najważniejsze odpowiedzi skupiają się na innych aspektach. Nie oczekuję, że ta odpowiedź wzrośnie do jakiegokolwiek znaczenia; jest to tutaj wyłącznie po to, abym mógł link do niej w komentarzach do pytań newbie.

Często potrzebujesz danych na przykład, jednak nie chcesz publikować dokładnych danych. Aby użyć niektórych istniejących danych.ramka w założonej bibliotece, użyj polecenia data, aby ją zaimportować.

Np.,

data(mtcars)

A potem zrób problem

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

Jeśli masz duży zbiór danych, którego nie można łatwo umieścić w skrypcie za pomocą dput(), wyślij swoje dane do pastebin i załaduj je za pomocą read.table:

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

Zainspirowany @ Henrik .

Rozwijam wakefield pakiet aby rozwiązać tę potrzebę szybkiego udostępniania powtarzalnych danych, czasami dput działa dobrze w przypadku mniejszych zestawów danych, ale wiele problemów, z którymi mamy do czynienia, jest znacznie większych, udostępnianie tak dużego zestawu danych za pośrednictwem dput jest niepraktyczne.

O:

wakefield pozwala użytkownikowi udostępnić minimalny kod do odtworzenia danych. Użytkownik ustawia n (ilość wierszy) i określa dowolne liczba wstępnie ustawionych funkcji zmiennych (obecnie jest ich 70), które naśladują rzeczywiste dane if (takie jak płeć, wiek, dochód itp.)

Instalacja:

Obecnie (2015-06-11), wakefield jest pakietem GitHub, ale trafi do CRAN w końcu po napisaniu testów jednostkowych. Aby szybko zainstalować, użyj:

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

Przykład:

Oto przykład:

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

To daje:

    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
.. ...   ... ...    ...      ... ...    ...   ...

Jeśli masz jedną lub więcej zmiennych factor, które chcesz odtworzyć za pomocą dput(head(mydata)), rozważ dodanie do nich droplevels, aby poziomy czynników, które nie są obecne w minimalizowanym zbiorze danych, nie były uwzględnione w wyjściu dput, Aby przykład minimal :

dput(droplevels(head(mydata)))

Ciekawe czy an http://old.r-fiddle.org / link może być bardzo zgrabnym sposobem dzielenia się problemem. Otrzymuje unikalne ID jak i można nawet pomyśleć o osadzeniu go w tak.

Proszę nie wklejać wyjść konsoli w ten sposób:

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")
)

Nie możemy skopiować-wkleić go bezpośrednio.

Aby pytania i odpowiedzi były właściwie powtarzalne, spróbuj usunąć + & > przed wysłaniem i wrzuceniem # do wyjścia i komentarzy takich jak:

#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")

Jeszcze jedno, jeśli użyłeś jakiejś funkcji z określonego pakietu, wspomnij o tej bibliotece.

Poza wszystkimi powyższymi odpowiedziami, które uznałem za bardzo interesujące, czasami może to być bardzo proste, ponieważ jest to omówione tutaj: - Jak zrobić minimalny powtarzalny przykład, aby uzyskać pomoc z R

Istnieje wiele sposobów, aby wektor losowy utworzyć wektor liczbowy 100 o losowych wartościach w R zaokrąglonych do 2 miejsc po przecinku lub macierz losową w R

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

Zauważ, że czasami bardzo trudno jest udostępnić dane z różnych powodów, takich jak wymiar itp. Jednakże, wszystkie powyższe odpowiedzi są świetne i bardzo ważne, aby myśleć i używać, gdy chce się odtworzyć przykład danych. Należy jednak pamiętać, że aby dane były tak reprezentatywne jak oryginał (w przypadku, gdy OP nie może udostępnić oryginalnych danych), dobrze jest dodać pewne informacje z przykładem danych jako (jeśli wywołamy dane mydf1)

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

Ponadto należy znać typ, długość i atrybuty danych, które mogą być strukturami danych

#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))

Oto niektóre z moich sugestii:

• spróbuj użyć domyślnych zestawów danych R
• Jeśli masz własny zestaw danych, dołącz je za pomocą dput, aby inni mogli Ci łatwiej pomóc
• nie używaj install.package() chyba, że jest to naprawdę konieczne, ludzie zrozumieją, jeśli po prostu używasz require lub library

• Staraj się być zwięzły,

  • mieć jakiś zbiór danych
  • spróbuj opisać dane wyjściowe tak prosto, jak to możliwe
  Zrób to sam, zanim zapytasz pytanie

Możesz to zrobić używając reprex.

Jako mt1022 zauważył , "... dobrym pakietem do produkcji minimalnego, powtarzalnego przykładu jest "reprex" z tidyverse".

Według Tidyverse :

Celem "reprex" jest spakowanie twojego problematycznego kodu w taki sposób, aby inni ludzie mogli go uruchomić i poczuć twój ból.

Przykład jest podany na stronie internetowej tidyverse .

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

Myślę, że to jest najprostszy sposób , aby stworzyć powtarzalny przykład.

Dobrym pomysłem jest użycie funkcji z pakietu testthat, aby pokazać, czego oczekujesz. W ten sposób inni ludzie mogą zmieniać twój kod, dopóki nie uruchomi się bez błędu. To zmniejsza ciężar tych, którzy chcieliby Ci pomóc, ponieważ oznacza to, że nie muszą dekodować Twojego opisu tekstowego. Na przykład

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

Jest jaśniejsze niż "myślę, że x wyjdzie na 1.23 Dla y równego lub przekraczającego 10, a 3.21 w przeciwnym razie, ale nie mam żadnego wyniku". Nawet w tym głupim przykładzie, myślę, że kod jest jaśniejszy niż słowa. Korzystanie z testthat pozwala twojemu pomocnikowi skupić się na kodzie, co oszczędza czas i zapewnia im sposób, aby wiedzieli, że rozwiązali twój problem, zanim go opublikują