Crearea fișelor de lucru R, Python, Stata și Julia (cu și fără soluții) folosind quarto

Introducere

În mod regulat, trebuie să produc exerciții/tutoriale pentru studenții mei. O caracteristică fantastică a R Markdown este aceea că îmi permite să creez un document R Markdown care poate fi redat atât documentului de întrebare, cât și documentului de soluții. Acest lucru se realizează prin comutarea opțiunilor de chunk knitr, cum ar fi evaluarea, ecoul și includerea și utilizarea bucăților ASIS pentru a include textul pentru soluții. Am scris un mic pachet,
Knitexercise pentru a ajuta cu asta.

Comutarea opțiunilor Knitr Chunk poate fi parametrizată, făcând posibilă un script R care conține codul pentru a produce în mod convenabil atât documente de întrebări, cât și de soluții. Un exemplu R Markdown File, Exercițiu.RMDar putea arăta ca următoarele.

---
title: "`r params$title`"
output: html_document
params:
  solutions: TRUE
  title: "Example exercise: Solutions"
---

```{r setup, include=FALSE}
knitr::opts_chunk$set(include = params$solutions)
```

1. This is question 1. Which might have some R code you always want to show.

   ```{r, include=TRUE}
   # example code for the question
   ```

   ```{asis}
   Paragraph text for the solution can be kept in the document in an `asis` chunk.
   And solution R code in an `r` chunk.
   Both of these will use the `include` value from the `setup` chunk.
   ```
    
   ```{r}
   # example code for the solution
   ```

2. This is question 2 ...

Și scriptul de redare ar putea arăta astfel.

rmarkdown::render("exercise.Rmd",
  output_file = "exercise-questions",
  params = list(solutions = FALSE, title = "Example exercise: Questions")
)

rmarkdown::render("exercise.Rmd",
  output_file = "exercise-solutions"
)

Cod inline

Codul inline a fost o caracteristică a R Markdown de ceva vreme. Yihui Xie și Christophe Dervieux au folosit -o pentru a scoate câteva trucuri fantastice. Trucul meu preferat este să -l folosesc pentru a scrie programatic codul R Markdown/Markdown într -un document R Markdown atunci când este îndeplinită o anumită condiție.

`r if (knitr::is_latex_output()) "...some_Markdown_to_include_when_rendering_to_pdf..."`

Problema

R Markdown este incredibil de flexibil, deoarece putem include obiecte R ca opțiuni de document și chunk. Când traduceți acest lucru într -o versiune de quarto pură, putem face acest lucru într -un document care utilizează în motorul knitr folosind
! expr ... Yaml Tag literal. Din câte știu, acest lucru nu este încă posibil pentru niciun alt motor cu quarto. În ciuda acestui fapt, scopul meu a fost să văd dacă pot realiza includerea/excluderea conținutului condiționat parametrizat într -un document de cvarto folosind alte motoare.

Includeți programatic conținut condiționat în documentele de cvarto

R: Knitr și Quarto

Am arătat deja abordarea R Markdown de mai sus.

Pentru quarto folosind motorul KNITR, într -o postare pe blog, Nicola Rennie a folosit codul inline pentru a scrie clasele de conținut condiționat ale Quarto.

---
format: html
params:
  hide_answers: true
---

```{r}
#| include: false
# An R code chunk, so inline code is not first in document.
```

`r if (params$hide_answers) "::: {.content-hidden}"`

Text and code for answers.

`r if (params$hide_answers) ":::"`

Rețineți că dacă utilizați bretelele cret în jurul r Pentru a vă scrie codul în linie, atunci trebuie să adăugați șirul de ieșire în
I() Funcționează după cum urmează.

`{r} if (params$hide_answers) I("::: {.content-hidden}")`

Apoi, putem avea un script shell pentru a reda documentele noastre de întrebări și soluții după cum urmează.

quarto render exercise-r.qmd -o exercise-r-questions.html
quarto render exercise-r.qmd -P hide_answers:false -o exercise-r-solutions.html

Piton

Mi -am dat seama că pot adapta abordarea lui Nicola Rennie pentru alte motoare. Pentru jupyter: python3 Motor putem face acest lucru după cum urmează, următorul cod folosește caracteristica parametrilor quarto.

---
format: html
jupyter: python3
---

```{python}
#| include: false
#| tags: (parameters)
hide_answers = True
```

```{python}
#| include: false
from IPython.display import Markdown
```

`{python} Markdown("::: {.content-hidden}") if hide_answers else Markdown(" ")`

```{python}
print("Hidden in questions")
```

`{python} Markdown(":::") if hide_answers else Markdown(" ")`

Scriptul shell pentru a reda documentele noastre de întrebări și soluții este următorul.

quarto render exercise-python.qmd -o exercise-python-questions.html
quarto render exercise-python.qmd -P hide_answers:False -o exercise-python-solutions.html

Singura problemă în acest sens este că, în prezent, celula de ieșire Papermill despre parametrii injectați este tipărită în document.

În Jupyter, acest lucru poate fi suprimat prin trecerea --report-mode Steag, dar nu am putut să rezolv cum să fac asta în quarto. Cred că va fi posibil să suprimăm această ieșire în versiunile viitoare ale quarto (folosesc cea mai recentă versiune de versiune actuală a Quarto 1.6.40).

Stata

Cazul Stata a implicat două trucuri suplimentare. În primul rând, nbstata jupyter kernel permite codul inline, cu toate acestea, acesta trebuie să fie un
display comandă, deci nu putem scrie instrucțiunea if din codul inline. Am descoperit că pot depăși acest lucru salvând diferitele șiruri în scalare (deoarece codul inline nu poate utiliza macro -uri locale) în partea de sus a documentului după cum urmează. În al doilea rând, nu am încercat, dar bănuiesc că kernelul NBSTATA nu acceptă parametrii și așa am obținut comutarea codului folosind o variabilă de mediu, de exemplu HIDE_ANSWERS_STATA.

---
format: html
jupyter: nbstata
---

```{stata}
*| include: false
local hide_answers : env HIDE_ANSWERS_STATA
if (`hide_answers') {
    scalar hide_answers_open = "::: {.content-hidden}"
    scalar hide_answers_close = ":::"     
}
else {
    scalar hide_answers_open = " "
    scalar hide_answers_close = " "
}
```

`{stata} scalar(hide_answers_open)`

```{stata}
display "Hidden in questions"
```

`{stata} scalar(hide_answers_close)`

Scriptul shell pentru a reda documentele este apoi după cum urmează, aici definim variabila de mediu înainte de apel la quarto.

HIDE_ANSWERS_STATA=1 quarto render exercise-stata.qmd -o exercise-stata-questions.html
HIDE_ANSWERS_STATA=0 quarto render exercise-stata.qmd -o exercise-stata-solutions.html

Iulia

Pentru motorul nativ Julia am descoperit că parametrizarea quarto a funcționat și că pot evita includerea ieșirii celulelor parametrilor injectați, lăsând bucățile cu parameters etichetă goală.

---
format: html
engine: julia
---

```{julia}
#| tags: (parameters)
```

```{julia}
#| include: false
using Markdown
```

`{julia} hide_answers ? md"::: {.content-hidden}" : md""`

```{julia}
println("Hidden in questions")
```

`{julia} hide_answers ? md":::" : md""`

Scriptul shell pentru a reda documentele este apoi după cum urmează.

quarto render exercise-julia.qmd -P hide_answers:true -o exercise-julia-questions.html
quarto render exercise-julia.qmd -P hide_answers:false -o exercise-julia-solutions.html

Probleme cu variabilele de mediu

Am constatat că variabilele de mediu trecătoare, către jupyter: python3 şi engine: julia este de încredere/rupt. Desigur, nu foloseam quarto în modul proiect cu un
_mediu Fișier, dar sincer nu mi se pare că ar trebui să fac asta pentru un singur document.

Problema pe care am descoperit -o a fost că, după o primă redare, valoarea variabilei de mediu pare să fie memorată în cache în documentul de ieșire a quarto și nu am putut să o modific pe redările ulterioare. Am mai constatat că folosind
dotenv Pachetul de acces a fost rupt în același mod.

Pentru engine: julia De asemenea, am constatat că variabilele de mediu care trece nu este de încredere și ca pentru jupyter: python3 Motor Am experimentat valori variabile de mediu fiind blocate după prima redare. Cu toate acestea, folosind Julia
Dotenv Pachetul părea să fie de încredere.

Rezumat

Am arătat cum să includ programatic conținut condiționat pentru mai multe motoare quarto (knitr, jupyter: python3, jupyter: nbstatași engine: julia) Utilizarea parametrilor sau a variabilelor de mediu pentru a comuta codul inline pentru a scrie marcajul cvarto în documentele Quarto. Folosesc acest lucru pentru a scrie documente de exercițiu/tutorial în care este utilizat un singur document de quarto pentru a scoate atât documentele de întrebări, cât și pentru soluții.