In appliedepi/introexercises:

library(introexercises)  # get data for exercises 
library(learnr)          # create lessons from rmd
library(gradethis)       # evaluate exercises
library(dplyr)           # wrangle data
library(flair)           # highlight code
library(ggplot2)         # visualise data
library(lubridate)       # work with dates
library(fontawesome)     # for emojis
library(janitor)         # clean data
# library(RMariaDB)        # connect to sql database

## set options for exercises and checking ---------------------------------------

## Define how exercises are evaluated 
gradethis::gradethis_setup(
  ## note: the below arguments are passed to learnr::tutorial_options
  ## set the maximum execution time limit in seconds
  exercise.timelimit = 60, 
  ## set how exercises should be checked (defaults to NULL - individually defined)
  # exercise.checker = gradethis::grade_learnr
  ## set whether to pre-evaluate exercises (so users see answers)
  exercise.eval = FALSE 
)

# ## event recorder ---------------------------------------------------------------
# ## see for details:
# ## https://pkgs.rstudio.com/learnr/articles/publishing.html#events
# ## https://github.com/dtkaplan/submitr/blob/master/R/make_a_recorder.R
# 
# ## connect to your sql database
# sqldtbase <- dbConnect(RMariaDB::MariaDB(),
#                        user = 'sander', 
#                        password = 'E9hqb2Tr5GumHHu',
#                        # user     = Sys.getenv("userid"),
#                        # password = Sys.getenv("pwd"),
#                        dbname   = 'excersize_log',
#                        host     = "144.126.246.140")
# 
# 
# ## define a function to collect data
# ## note that tutorial_id is defined in YAML
#     ## you could set the tutorial_version too (by specifying version:) but use package version instead
# recorder_function <- function(tutorial_id, tutorial_version, user_id, event, data) {
# 
#   ## define a sql query
#   ## first bracket defines variable names
#   ## values bracket defines what goes in each variable
#   event_log <- paste("INSERT INTO responses (
#                        tutorial_id,
#                        tutorial_version,
#                        date_time,
#                        user_id,
#                        event,
#                        section,
#                        label,
#                        question,
#                        answer,
#                        code,
#                        correct)
#                        VALUES('", tutorial_id,  "',
#                        '", tutorial_version, "',
#                        '", format(Sys.time(), "%Y-%M%-%D %H:%M:%S %Z"), "',
#                        '", Sys.getenv("SHINYPROXY_PROXY_ID"), "',
#                        '", event, "',
#                        '", data$section, "',
#                        '", data$label,  "',
#                        '", paste0('"', data$question, '"'),  "',
#                        '", paste0('"', data$answer,   '"'),  "',
#                        '", paste0('"', data$code,     '"'),  "',
#                        '", data$correct, "')",
#                        sep = '')
# 
#     # Execute the query on the sqldtbase that we connected to above
#     rsInsert <- dbSendQuery(sqldtbase, event_log)
# 
# }
# 
# options(tutorial.event_recorder = recorder_function)

# hide non-exercise code chunks ------------------------------------------------
knitr::opts_chunk$set(echo = FALSE)

# data prep --------------------------------------------------------------------
surv_raw <- rio::import(system.file("dat/surveillance_linelist_20141201.csv", package = "introexercises"))

tests <- rio::import(system.file("dat/testing_data.csv", package = "introexercises"))

Introduction à R pour l'épidémiologie appliquée

Bienvenue

Bienvenue dans la formation "Introduction à R pour l'épidémiologie appliquée", proposée par . Epi appliquée - une organisation à but non lucratif qui propose des formations, un soutien et des outils open-source aux praticiens de la santé publique de première ligne.

knitr::include_graphics("images/logo.png", error = F)

Configuration de R, syntaxe de base et importation de données

Cet exercice se concentre sur l'installation de R pour la première fois et une introduction au codage R de base.

Format

Cet exercice te guide dans les tâches que tu dois effectuer dans RStudio sur ton ordinateur local.

Obtenir de l'aide

Il y a plusieurs façons d'obtenir de l'aide :

1) Cherche les "aidants" (voir ci-dessous). 2) Demande de l'aide à ton instructeur/animateur de cours en direct 3) Planifie un appel avec un instructeur pour un "tutorat de cours". 4) Poser une question dans Communauté Epi appliquée

Voici à quoi ressembleront ces "aides" :

r fontawesome::fa("lightbulb", fill = "gold") Cliquez pour lire un indice

.

Tu trouveras ici un conseil utile !

r fontawesome::fa("check", fill = "red")Cliquez pour voir une solution (essayez-la d'abord vous-même !)

.

linelist %>% 
  filter(
    age > 25,
    district == "Bolo"
  )

Voici plus d'explications sur la raison pour laquelle la solution fonctionne.

Questions du quiz

Répondre aux questions du quiz t'aidera à comprendre la matière. Les réponses ne sont pas enregistrées.

Pour t'entraîner, réponds aux questions suivantes :

quiz(
  question_radio("When should I view the red 'helper' solution code?",
    answer("After trying to write the code myself", correct = TRUE),
    answer("Before I try coding", correct = FALSE),
    correct = "Reviewing best-practice code after trying to write yourself can help you improve",
    incorrect = "Please attempt the exercise yourself, or use the hint, before viewing the answer."
  )
)

question_numeric(
 "How anxious are you about beginning this tutorial - on a scale from 1 (least anxious) to 10 (most anxious)?",
 answer(10, message = "Try not to worry, we will help you succeed!", correct = T),
 answer(9, message = "Try not to worry, we will help you succeed!", correct = T),
 answer(8, message = "Try not to worry, we will help you succeed!", correct = T),
 answer(7, message = "Try not to worry, we will help you succeed!", correct = T),
 answer(6, message = "Ok, we will get there together", correct = T),
 answer(5, message = "Ok, we will get there together", correct = T),
 answer(4, message = "I like your confidence!", correct = T),
 answer(3, message = "I like your confidence!", correct = T),
 answer(2, message = "I like your confidence!", correct = T),
 answer(1, message = "I like your confidence!", correct = T),
 allow_retry = TRUE,
 correct = "Thanks for sharing. ",
 min = 1,
 max = 10,
 step = 1
)

Permis

Envoie un courriel à l'adresse suivante [e-mail] pour toute question concernant l'utilisation de ce matériel.

Objectifs d'apprentissage

Dans cet exercice, tu vas :

• te familiariser avec l'interface de RStudio
• S'entraîner à ouvrir un nouveau script R et à exécuter des "commandes".
• Apprends la syntaxe de base, les opérateurs et les fonctions
• Installer et charger des paquets R
• Importe un ensemble de données simple dans R et explore son contenu

Préparation au cours

Si tu n'as pas pu réaliser les installations avant le cours, alerte dès maintenant l'un des instructeurs.

Installer le logiciel

Les logiciels suivants doivent être installés sur ton ordinateur avant le début du cours.

1) R (version la plus récente) 2) RStudio (version la plus récente) 3) RTools (uniquement pour les machines Windows, et pas strictement nécessaire)

Si tu as des difficultés, consulte un instructeur ou vois le guide d'installation dans le dossier du cours pour obtenir des conseils (voir l'étape suivante).

Télécharger les fichiers du cours

Si tu ne l'as pas encore fait, télécharge le dossier zippé du cours à l'adresse suivante . ce lien.

Décompresse/extracte le dossier et enregistre-le sur le bureau de ton ordinateur - pas sur un disque partagé.

Pour "décompresser" un dossier une fois qu'il a été téléchargé, clique avec le bouton droit de la souris sur le dossier et sélectionne "Extraire tout". Si tu as le choix de l'emplacement où enregistrer le dossier décompressé, enregistre-le sur ton bureau.

La structure du dossier devrait ressembler à ceci :

• r emo::ji("folder") Bureau
• r emo::ji("folder") intro_course
  • r emo::ji("folder") ebola
  • r emo::ji("folder") covid
  • r emo::ji("folder") module1
  • r emo::ji("folder") matériel_d'apprentissage
  • r emo::ji("document") paquets_à_installer.R

Installer les paquets R

Tu devrais déjà avoir installé les paquets R pour le cours.

Si ce n'est pas le cas, suis les instructions suivantes :

1) Va dans le dossier "intro_course", et ouvre le fichier "packages_to_install.R". Si c'est la première fois que tu ouvres un script R sur ton ordinateur, il se peut que tu doives préciser que tu veux ouvrir le fichier à l'aide de RStudio.

• r emo::ji("folder") Bureau
• r emo::ji("folder") intro_course
  • r emo::ji("folder") ebola
  • r emo::ji("folder") covid
  • r emo::ji("folder") module1
  • r emo::ji("folder") matériel_d'apprentissage
  • r emo::ji("document") paquets_à_installer.R

2) Suis les instructions en haut du script. Mets en évidence TOUS le texte du script et appuie sur le bouton "Exécuter" situé en haut au centre de RStudio. Tu peux aussi surligner tout le texte et appuyer sur les touches Ctrl et Entrée.

Ce script prendra plusieurs minutes pour installer la plupart des paquets R dont tu as besoin pour ce cours.

Comprendre R et RStudio

Si tu ne l'as pas encore fait, ouvre maintenant RStudio.

Comprendre R

R est un langage utilisé pour le calcul statistique et les graphiques, développé en 1991 et basé sur le langage S (plus d'infos sur l'histoire de R ici). R est différent des autres langages de programmation en ce sens que son objectif initial est de traiter les données. l'analyse.

R se distingue des autres langages d'analyse de données parce que :

• Il est gratuit (plus de frais de licence !)
• Il est open-source (de nouvelles fonctionnalités sont créées par la communauté des utilisateurs)
• Il possède des capacités graphiques avancées
• Il possède des capacités de rapports automatisés polyvalents (très utiles en santé publique !)
• Il dispose d'une communauté d'utilisateurs de la santé publique grandissante, inclusive et dynamique.

Pourquoi est-il important que R soit "open-source" ?

R n'est pas une entreprise, et il n'y a pas de "siège social" de R. Parce que R est "open-source", ses outils sont créés et validés par ses millions d'utilisateurs. Cette décentralisation du pouvoir est intrinsèquement démocratisante et permet à R de répondre rapidement aux besoins émergents (par exemple, la pandémie de COVID-19). De nombreuses institutions majeures font confiance à R et l'utilisent : par exemple, la Food and Drug Administration (FDA) des États-Unis.

La base du logiciel R est régie par un "groupe de base" et mise à jour tous les quelques mois. Chaque version de R se voit attribuer un numéro (comme "R version 4.1.2 (2021-11-01)") et un nom pour la rendre plus facile à retenir, comme "Bird Hippie". À l'avenir, tu pourras facilement mettre à jour ta version de R en la téléchargeant à nouveau. Souvent, R et RStudio t'inviteront à télécharger les nouvelles versions lorsqu'elles seront disponibles.

Comprendre RStudio

RStudio est une interface qui permet d'utiliser R. Bien qu'il soit possible d'ouvrir et d'utiliser R directement, il est beaucoup plus courant de l'utiliser par le biais d'un environnement de développement intégré (IDE) tel que RStudio, qui permet une expérience plus conviviale et une organisation plus facile des fichiers. "RStudio" est proposé gratuitement par la société Posit.

Lorsque tu ouvres RStudio, il trouve et utilise automatiquement le R installé sur ton ordinateur. Il n'est pas nécessaire d'ouvrir les deux programmes.

Tu peux penser à R comme le moteur d'un véhicule qui fait le travail essentiel, et RStudio comme la carrosserie du véhicule (le châssis, les sièges, les accessoires, etc.).

Quiz

Maintenant, vérifie ta compréhension de R et de RStudio en répondant aux questions ci-dessous :

quiz(caption = "Quiz - R and RStudio",

   question("What is RStudio?",
            allow_retry = TRUE,
    answer("An application that makes it easier to use R.",
           correct = TRUE,
           message = "RStudio is an 'Integrated Development Environment (IDE) that makes it easier to write, use, debug, and save R code."),
    answer("A spreadsheet program like Microsoft Excel."),
    answer("Another name for R",
           message = "R and RStudio are two separate things. R is a language, like English or French. RStudio can be thought of as a program that helps you use the language, like how a word processing program helps you write."),
    answer("An application that lets you use R without writing any code",
           message = "You still have to write code - and that's a good thing! Code provides a reproducible record of your work, which is best practice.")
  ),


  question("Is RStudio free to download and use?",
    answer("Yes",
           correct = TRUE,
           message = "The RStudio IDE is a software offered for free by the company Posit. There are other, less common, IDEs to use R, such as Tinn-R and Emacs."),
    answer("No",
           message = "RStudio IDE is free and open-source.")
  ),

  question("Do you need to install both R and RStudio?",
    answer("Yes",
           correct = TRUE,
           message = "While it is possible to work in R without an interface like RStudio, this is not recommended for beginners."),
    answer("No",
           message = "While it is possible to work in R without an interface like RStudio, this is not recommended for beginners.")
  ),

  question("Once both programs are installed, which one should you open to begin working?",
    answer("RStudio",
           correct = TRUE,
           message = "Opening RStudio will automatically start R."),
    answer("R",
           message = "For beginners, it is best to work in R *through* RStudio. Open RStudio."))
)

Visite de RStudio

Regarde autour de RStudio. Observe les principaux panneaux de RStudio. Tu devrais voir 3 ou 4 panneaux :
1) Le console (à gauche ou en bas à gauche)
2) Le L'environnement (en haut à droite)
3) Le Fichiers, tracés, paquets, aide et visionneuse (en bas à droite)
4) Les Source (en haut à gauche) Si tu ne vois que ces 3 volets, clique sur Fichier -> Nouveau fichier -> Script R pour ouvrir un nouveau script R et obtenir l'aspect classique ci-dessous.

Prends quelques minutes pour te familiariser avec l'emplacement des différents volets, à l'aide du schéma ci-dessous.

# adding xfun::relative_path() creates a dynamic file path between the Rmd location and the here() path.
# It dynamically creates the ../../etc filepath.

knitr::include_graphics("images/rstudio_overview.png", error = F)

Le volet Source (en haut à gauche)

Ce volet est un espace où tu peux éditer et exécuter tes scripts C'est là que tu écris les commandes R. Ce volet affiche également les ensembles de données. Pour les utilisateurs de Stata, ce volet est similaire aux fenêtres Do-file et Data Editor.

Le panneau de la console R (en bas à gauche)

Il s'agit du logiciel R lui-même - le "moteur" qui exécute les commandes. Les sorties non graphiques et les messages d'erreur ou d'avertissement apparaissent ici. Tu peux taper des commandes dans la console R, mais elles ne sont pas enregistrées comme lorsqu'elles sont exécutées à partir d'un script. Si tu connais Stata, la console R ressemble à la fenêtre de commande et à la fenêtre de résultats.

Le volet Environnement (en haut à droite)

Ce volet montre les objets disponibles, qui peuvent inclure des ensembles de données ou des valeurs spécifiques que tu as sauvegardées pour une utilisation ultérieure (par exemple, un nombre spécifique de "epiweek"). Dans Stata, ce volet est très similaire à la fenêtre Variables Manager.

Fichiers, tracés, paquets, aide et volet de visualisation (en bas à droite)

Le volet comprend plusieurs onglets. Le volet Fichiers est un navigateur qui permet d'ouvrir, de renommer ou de supprimer des fichiers. Le volet Tracé affiche les graphiques et les tracés, tandis que les sorties interactives s'affichent dans le volet Visionneuse. Le volet Aide affiche la documentation et les fichiers d'aide. Le volet Packages te permet d'installer, de mettre à jour et de charger/décharger des packages R. Ce volet contient les équivalents Stata des fenêtres Plots Manager et Project Manager.

Pour plus de détails sur les fonctionnalités de RStudio, télécharge ce PDF : Fiche d'information sur l'IDE RStudio.

Paramètres de l'espace de travail RStudio

Lorsque tu installes RStudio pour la première fois, il est important d'ajuster un paramètre par défaut.

Suis les étapes suivantes dans ta session RStudio :

1. Va dans le RStudio Outils (ce menu déroulant se trouve en haut de RStudio).
2. Sélectionne l'option finale "Options globales" et tu verras apparaître la fenêtre pop-up.

# adding xfun::relative_path() creates a dynamic file path between the Rmd location and the here() path.
# It dynamically creates the ../../etc filepath.

knitr::include_graphics("images/RStudio_tools_options_1.png", error = F)

1. Voir la section de l'onglet Général intitulée "Espace de travail" et désélectionne la case à cocher "Restaurer les .RData dans l'espace de travail au démarrage".
2. Règle le menu déroulant juste en dessous sur "Ne jamais" sauvegarder l'espace de travail en .RData à la sortie.

# adding xfun::relative_path() creates a dynamic file path between the Rmd location and the here() path.
# It dynamically creates the ../../etc filepath.

knitr::include_graphics("images/options_rdata.png", error = F)

Pourquoi suggérons-nous cela ? À long terme, tu deviendras un meilleur codeur si RStudio commence vide ou avec une "table rase" chaque fois que tu l'ouvres. Cela t'oblige à écrire un code complet, qui ne repose jamais sur ce que tu as fait lors d'une session précédente. Cela rend ton analyse plus "reproductible" et évite les maux de tête lorsque tu partages le code avec d'autres personnes.

Projets RStudio

Ensuite, tu vas mettre en place un projet RStudio.

Un environnement R autonome et portable

Un projet RStudio est un environnement de travail R autonome et portable - effectivement un dossier pour tous les fichiers associés à un projet distinct (fichiers de données, scripts R, sorties, etc.).

• Tu peux zipper un projet et l'envoyer par courriel - ils peuvent l'ouvrir et reproduire ton travail à l'identique !
• Un projet peut être lié à un logiciel de contrôle de version comme Git/Github.

# adding xfun::relative_path() creates a dynamic file path between the Rmd location and the here() path.
# It dynamically creates the ../../etc filepath.

knitr::include_graphics("images/project_briefcase.png", error = F)

Si tu ne travailles pas dans le cadre d'un projet RStudio, il sera plus difficile d'organiser les fichiers, d'importer des données et de faire en sorte que tes scripts soient utilisés par des personnes sur d'autres ordinateurs.

Projets dans ce cours

Pendant ce cours, tu créeras au moins 3 projets RStudio dans le dossier "intro_course" :

1) Un projet pour Module 1 (pratique) 2) Un projet d'analyse d'un Ebola d'Ebola 3) Un projet d'analyse d'un COVID-19 de COVID-19

Crée un projet RStudio pour le module 1

Suis les étapes suivantes pour créer un projet RStudio pour le module 1:

1) Ouvrir RStudio (assure-toi d'ouvrir RStudio et pas seulement R).

2) Dans RStudio, en haut à gauche, clique sur Fichier -> Nouveau projet. Dans la fenêtre pop-up, sélectionne "Répertoire existant".

knitr::include_graphics("images/create_project.png")

3) Créer le projet dans le sous-dossier "intro_course/module1"

• Clique sur "Parcourir" et navigue jusqu'au dossier "intro_course" que tu as téléchargé et décompressé plus tôt (probablement sauvegardé sur ton bureau). puis dans le sous-dossier "module1"..
• Clique sur "Créer un projet" (RStudio peut se fermer brièvement et se rouvrir).

Voilà ! Ce sera le projet pour ton travail dans ce premier module.

Confirme que tu es dans un projet

Si tu travailles dans un projet RStudio, tu verras le nom du projet dans le coin supérieur droit de RStudio. Si tu n'es pas dans un projet RStudio, tu verras "Projet : (Aucun)". Que vois-tu dans ton RStudio ?

# adding xfun::relative_path() creates a dynamic file path between the Rmd location and the here() path.
# It dynamically creates the ../../etc filepath.

knitr::include_graphics("images/Rproject_dropdown.png", error = F)

Explore ton projet RStudio

r fontawesome::fa("window-restore", fill = "darkgrey") Réduis RStudio et ouvre le navigateur de dossiers de ton ordinateur (par exemple l'explorateur Windows). Navigue jusqu'au dossier "module1". Le contenu du dossier doit maintenant ressembler à ceci :

knitr::include_graphics("images/new_r_project_explorer.png", error = F)

Dans le dossier, tu devrais voir un petit fichier avec une icône qui ressemble à une "boîte R" - il s'agit du fichier de projet RStudio (.Rproj).

Pour ouvrir le projet la prochaine fois, il suffit de double-cliquer sur ce fichier de projet. RStudio s'ouvrira et tous les fichiers de ce projet seront prêts à l'emploi.

Observe que dans RStudio dans le volet "Fichiers" (en bas à droite), le contenu du projet est également visible.

knitr::include_graphics("images/new_r_project.png", error = F)

Tu peux en savoir plus sur les projets RStudio dans ce chapitre du manuel Epi R.

Exécution des commandes R

Démarrer un script R

Si tu ne l'as pas encore fait, ouvre un nouveau script R en cliquant sur Fichier -> Nouveau fichier -> Script R.

knitr::include_graphics("images/new_script.jpg", error = F)

Tu devrais voir apparaître un espace vide en haut à gauche de RStudio. Cet espace est le script R.

knitr::include_graphics("images/RStudio_new_script.png", error = F)

Actuellement, le script n'est pas sauvegardé. Clique sur l'icône de sauvegarde au-dessus du script, ou clique sur Fichier -> Enregistrer sous.

Nomme le script "module1_script.R" et assure-toi qu'il est enregistré dans le dossier "module1".

Note que l'extension de fichier pour un script R est ".R". En travaillant avec R, tu rencontreras d'autres extensions, mais n'oublie pas que celle-ci est destinée aux scripts R.

r fontawesome::fa("eye", fill = "darkblue") Observe que ton script doit maintenant apparaître dans le volet "Fichiers" (en bas à droite de RStudio) dans le dossier "module1".

quiz(
  question("Which of these file names is an R script?",
           allow_retry = TRUE,
    answer("survey_analysis.Rproj", message = "No, this extension signifies an R project. You could click this to open RStudio and work on the project."),
    answer(".Rhistory", message = "No, .Rhistory is a special file that saves a record of commands and outputs. It is rarely viewed."),
    answer("cholera_plots.Rmd", message = ".Rmd signifies an 'R markdown' script, which is not a standard R script. You'll learn about R markdown later in the course."),
    answer("measles.R", correct = TRUE, message = "Yes, the .R signifies that this is an R script."),
    answer("pirate_ship.arrrrr", message = "No, this is just silly!")
  )
)

Un script est une liste d'instructions pour R

Un script est un endroit où écrire commandes (instructions) pour R. Un script R typique pour la santé publique peut inclure des sections comme :

• Une description des auteurs, l'objectif de l'analyse et la date de la dernière mise à jour.
• Charger les paquets R
• Importer les données
• Nettoyer les données
• Effectuer des analyses sommaires et statistiques
• Afficher les résultats sous forme de graphiques, de tableaux, de cartes, etc.

Dans l'exemple ci-dessous, le texte vert et les symboles dièse (#) sont des "commentaires" ou des "notes" destinés au lecteur, ou utilisés pour délimiter des sections du script. Le texte noir correspond aux commandes du code R.

NE TAPE PAS L'EXEMPLE DE CODE CI-DESSOUS DANS TON SCRIPT R
Examine simplement le format, en te concentrant sur la façon dont le code # est utilisé pour commenter ou créer des titres de section. Tu auras l'occasion d'écrire des scripts de ce type plus tard dans le cours.

knitr::include_graphics("images/example_script.png", error = F)

Ecris des commandes R simples

r fontawesome::fa("terminal", fill = "black") Faisons un peu de codage !

R comme calculatrice

Pour te familiariser avec l'exécution des commandes, commençons par l'utilisation la plus simple de R, celle d'une calculatrice.

Tu trouveras ci-dessous les opérateurs mathématiques les plus courants dans R. Ils sont souvent utilisés pour effectuer des additions, des divisions, pour créer de nouvelles colonnes dans les ensembles de données, etc. Les espaces autour des opérateurs n'affectent pas la commande, mais rendent le code plus lisible.

| Objectif | Exemple en R | | --------------------------- | ------------------------------------- | | addition | 2 + 3 | | soustraction | 2 - 3 | | multiplication | 2 * 3 | | division | 30 / 5 | | exposant | 2^3 | | ordre des opérations | ( ) |

Sois à l'aise pour écrire et exécuter des commandes

Comme le montre la démonstration, tu peux exécuter des commandes R par l'intermédiaire de la console de la façon suivante :

• Tu peux taper directement dans le volet de la (en bas à gauche de RStudio) et exécuter la commande en appuyant sur Entrée.

knitr::include_graphics("images/RStudio_run_console.png", error = F)

Le [1] avant le 62 t'informe qu'il s'agit de la première (et dans ce cas de la seule) sortie.

• Tu peux taper dans le script puis exécuter la commande de l'une des façons suivantes :

• Place ton curseur sur la ligne du script et appuie sur le bouton "Exécuter".

• Place ton curseur sur la ligne, puis appuie sur Ctrl et Entrée (ou Cmd et Entrée sur un Mac).
• Surligne tout ou seulement une partie de la commande si tu veux exécuter seulement une partie de la commande, appuie sur "Exécuter" ou sur Ctrl et Entrée

knitr::include_graphics("images/RStudio_run_script.png", error = F)

Note que les résultats apparaîtront toujours dans la Console, même si la commande est exécutée à partir du script.

Tape quelques commandes mathématiques simples dans le script R. Essaie d'exécuter les commandes de TOUTES les façons indiquées ci-dessus. Quelle est la méthode que tu préfères pour exécuter une commande ?

Maintenant, exécute les commandes dans ton script R pour trouver les solutions au problème mathématique simple suivant :

quiz(caption = "R as a calculator",
  question_numeric(
    "What is the sum of 12, -99, 2, 147, and 29?",
    answer(91, message = "Excellent!", correct = T),
    allow_retry = TRUE,
    correct = "Correct, nice work.",
    min = 1,
    max = 3000,
    step = 1
  )
)

Si tu as du mal à écrire le code, passe en revue l'astuce ci-dessous ! La solution est également fournie si nécessaire.

r fontawesome::fa("lightbulb", fill = "gold") Cliquez pour lire un indice

.

Utilise l'opérateur d'addition + entre les chiffres, place le curseur sur cette ligne du script et appuie sur le bouton "Exécuter" en haut à droite du script. N'oublie pas que la deuxième valeur est NÉGATIVE 99.

r fontawesome::fa("check", fill = "red")Cliquez pour voir une solution (essayez-la d'abord vous-même !)

.

12 + -99 + 2 + 147 + 29

COVID-19 Exercice sur la chaîne d'approvisionnement

Essayons de développer un code pour une question plus pertinente pour la santé publique :

Tu gères une campagne de tests COVID-19 sur 3 sites, et tu dois passer une commande d'approvisionnement en tests rapides pour le mois prochain. D'après les informations suivantes, combien de tests dois-tu commander pour le mois prochain ?

• Le site 1 utilise 200 tests par mois
• Le site 2 utilise 550 par mois
• Le site 3 a deux sous-sites qui nécessitent chacun 925 tests par mois.
• Tu devrais commander 10 % de plus pour faire face à une demande plus importante.
• Il te reste 420 tests supplémentaires du mois dernier, que tu peux utiliser dans le mois à venir.

Écris et exécute une commande dans ton script pour calculer le nombre de tests que tu dois commander pour le mois prochain Si tu as du mal à démarrer, passe d'abord en revue l'astuce ci-dessous !

r fontawesome::fa("lightbulb", fill = "gold") Cliquez pour lire un indice

.

Utilise les parenthèses ( ), l'opérateur de multiplication astérisque et les opérateurs d'addition + et de soustraction -. Tout d'abord, additionne les besoins connus (200, 550 et deux fois 925). Mets tout cela entre parenthèses, car tu dois multiplier cette somme par le tampon souhaité (110 %, mais sous forme décimale). Ce total doit également être mis entre parenthèses, car tu dois ensuite soustraire le surplus du mois précédent (qui n'a pas besoin d'être acheté).

r fontawesome::fa("check", fill = "red")Cliquez pour voir une solution (essayez-la d'abord vous-même !)

.

((200 + 550 + (925 * 2)) * 1.1) - 420

quiz(caption = "Supply chain exercise",
  question_numeric(
    "How many tests should you order for the coming month?",
    answer(2440, correct = T),
    allow_retry = TRUE,
    correct = "Correct, nice work.",
    incorrect = "Try again, or view the hint above. Think about order of operations...",
    min = 1,
    max = 3000,
    step = 1
  ),
  question(
    "Where in RStudio was the answer printed?",
    allow_retry = TRUE,
    answer("The R Console, in the lower-left", correct = TRUE),
    answer("The Plots pane, in the lower-right", message = "No it was not printed to the Plots pane. Check the Console in the lower-left."),
    answer("In the R Script", message = "No, it was not printed in the R Script. Look below at the Console pane.")
  )
)

Documentation

r fontawesome::fa("pen", fill = "brown") Il est important d'écrire des notes dans ton scénario pour que d'autres personnes (et toi à l'avenir) puissent le comprendre !

Un symbole "dièse" (#) désactive tout texte écrit à sa droite et est utilisé pour insérer des commentaires dans le script.

Par exemple :

# This is a comment in the script 
# This is another comment

2 + 2  # this is a comment after some active R code

Mets à jour ton script pour qu'il contienne ce qui suit:

• Un en-tête qui décrit l'objectif de la commande (calculs du test COVID-19).
• Des instructions détaillées sur les commandes
• Des espaces entourent tous les opérateurs mathématiques, comme indiqué ci-dessous.

Les futurs lecteurs de ton code te remercieront !

Tu trouveras une solution possible ci-dessous.

r fontawesome::fa("check", fill = "red")Cliquez pour voir une solution (essayez-la d'abord vous-même !)

.

Note que l'auteur, la date et l'email de contact doivent refléter tes propres détails (par exemple, ton nom, la date du jour et tes coordonnées).

# Purpose: Calculate monthly order for testing supplies
# Author: Neale Batra
# Last updated: 2 February, 2024  
# Contact email: [e-mail]

# Site 1 uses 200 per month  
# Site 2 uses 550 per month  
# Site 3 has 2 sub-sites that each need 925 tests per month  
# Order 10% extra as a buffer against higher demand  
# At the end, subtract the number of tests remaining from last month  

((200 + 550 + (925 * 2)) * 1.1) - 420

Création d'objets

Types d'objets

R te permet de stocker des objets pour une utilisation ultérieure. Ils sont stockés dans ta base de données R Environnement le volet en haut à droite de RStudio.

Tout ce que tu stockes dans R - les ensembles de données, les variables, une liste de noms de villages, un nombre total de population, et même les résultats tels que les graphiques - sont des fichiers de données. objets qui sont un nom de ton choix qui peut être référencé dans les commandes suivantes. Dans n'importe quel script, tu peux créer ("définir") et redéfinir des centaines d'objets !

Quelques exemples :

• Valeurs uniques :
• A numérique nommé epiweek avec la valeur 14
• A caractère nommé city avec la valeur "Kigali"
• A logique nommé run_report dont la valeur est soit TRUE ou FALSE
• Un "cadre de données"
• Un ensemble de données importé dans R à partir d'Excel, de CSV ou d'un autre format de fichier, auquel on donne par exemple un nom tel que linelist ou hospital_data
• Un "vecteur"
• Une séquence de valeurs uniques, par exemple une séquence de couleurs à utiliser dans un diagramme à barres, nommée "vecteur". my_colors

Nous explorerons les différents types d'objets plus tard, mais pour l'instant, exerçons-nous à définir des objets simples.

L'opérateur d'affectation

Crée des objets en leur attribuant une valeur à l'aide de l'"opérateur d'affectation" : <-

Tu peux penser à l'opérateur d'affectation <- comme les mots "est défini comme".

Cet opérateur ressemble à une flèche. Il prend le valeur du côté droit, et l'affecte à l'élément nom du côté gauche. Les commandes d'attribution suivent généralement un ordre standard :

nom_objet \<- valeur (ou calcul/processus qui produit une valeur)

En exécutant la commande avec l'opérateur d'affectation, tu peux créer un objet, ou en réexécutant la commande, tu peux redéfinir l'objet avec une nouvelle valeur.

Astuce : Le raccourci clavier pour créer le <- est Alt et - (Windows) ou Option et - (Mac).

Environnement R

r fontawesome::fa("eye", fill = "darkblue") Regarde ton volet "Environnement" dans RStudio. Pour l'instant, il ne devrait pas y avoir d'entrées dans le volet Environnement, car nous n'avons pas encore défini d'objets.

# adding xfun::relative_path() creates a dynamic file path between the Rmd location and the here() path.
# It dynamically creates the ../../etc filepath.

knitr::include_graphics("images/empty_environment.png", error = F)

Maintenant, écris le code ci-dessous dans ton script R et exécute la commande.

Rappelle-toi que pour exécuter une commande dans ton script, il faut soit surligner toute la commande, soit placer ton curseur dans la commande, et cliquer sur "Exécuter".

Tape la commande (ne te contente pas de copier/coller !) pour te familiariser avec la saisie des commandes R !

confirmed_cases <- 34

Remarque que l'objet confirmed_cases est maintenant Environment, avec la valeur de 34. Maintenant, nous pouvons exécuter d'autres commandes à l'aide de l'objet confirmed_cases et R saura qu'il faut utiliser la valeur 34.

quiz(
   question_checkbox("When you ran the command above to define an object, what happened in RStudio (select ALL that are correct)?",
    answer("A new stored object appeared in the Environment pane, named 'confirmed_cases', with a value of 34",
           correct = TRUE,
           message = ""),
    answer("The command that was run appeared in the Console (lower-left) pane",
           correct = TRUE,
           message = "Note that only the command appeared in the R Console, not any calcuated output"),
    answer("34 appeared in the Console as calculated output",
           message = "This command simply assigns a value to a object name, it does not ask R to print the result of any calculation"),
    allow_retry = TRUE
  )
)

r fontawesome::fa("pen", fill = "brown") Notes sur la dénomination des objets :

• Les noms d'objets ne doivent pas contenir d'espaces Les noms d'objets ne doivent pas contenir d'espace, mais tu peux utiliser un trait de soulignement (_) ou un point (.) à la place d'un espace.
• Les noms d'objets sont sensibles à la casse (ce qui signifie que Dataset_A est différent de dataset_A).
• Les noms d'objets doivent commencer par une lettre (ils ne peuvent pas commencer par un chiffre comme 1, 2 ou 3).
• Généralement, les codeurs écrivent les noms d'objets en minuscules, mais il s'agit d'un choix stylistique
• Garde des noms d'objets courts - il est beaucoup plus facile de coder avec des noms courts.

r emo::ji("cross mark") my object name
r emo::ji("cross mark") Ayant à la fois dataset et Dataset
r emo::ji("cross mark") 2nd_wave_of_cases_from_Santa_Clara_County

r emo::ji("check") cases_zambia
r emo::ji("check") linelist_raw
r emo::ji("check") lab_20140216

Note : dans la littérature R, tu verras souvent des gens utiliser df comme nom d'objet. Il s'agit d'une façon très abrégée de faire référence au fait que l'objet qu'ils enregistrent est un "data frame" (ensemble de données avec des colonnes et des lignes).

Commandes d'impression et d'enregistrement

Maintenant, exécute une commande contenant uniquement le nom de l'objet confirmed_cases (regarde le panneau de la console R pour la sortie)* :

confirmed_cases

Cette commande demande à R de d'imprimer (également appelé "return") le valeur assignée à l'objet confirmed_cases. La valeur 34 a été imprimée sur la console.

Cela soulève un point critique que tu dois comprendre en tant qu'utilisateur débutant de R - il existe deux types fondamentaux de commandes R :

1) Sauvegarde des commandes qui utilisent le <- pour enregistrer un objet.
Un objet de ton environnement sera créé ou modifié. L'enregistrement de la commande sera imprimé sur la console, mais aucun des objets de ton environnement ne sera créé ou modifié. valeur de sortie.

2) Commandes d'impression qui impriment une sortie sur une console (et n'utilisent pas l'option <-).
R va imprimera la commande et un valeur à la console, mais ne pas apporter de modifications durables aux objets de l'environnement.

Demande-toi toujours : "Qu'est-ce que ma commande demande à R de faire ? Imprimer ? ou Enregistrer ?". Nous renforcerons ce point à l'aide d'exemples tout au long du cours.

Fabrique un autre objet

Crée un objet nommé suspect_cases et lui assigner la valeur 12. Exécute cette commande dans ta console pour t'assurer que l'objet suspect_cases est créé dans ton environnement avec la valeur 12 qui lui a été attribuée.

r fontawesome::fa("check", fill = "red")Cliquez pour voir une solution (essayez-la d'abord vous-même !)

.

suspect_cases <- 12

Maintenant, écris et exécute la commande suivante Vois comment tu peux maintenant faire référence aux valeurs en appelant uniquement les noms attribués.

total_cases <- confirmed_cases + suspect_cases

quiz(
  question("Was this command a PRINTING command, or a SAVING command?",
    answer("Printing",
           message = "No, there was an arrow used, and NO output number was printed to the Console."),
    answer("Saving",
           message = "Yes, there was an arrow used, and a new object was saved to the environment.",
           correct = TRUE),
    allow_retry = TRUE
  ),

   question("When the above command is run, did the value of total_cases print in the R console?",
    answer("Yes", message = "This command used the assignment operator, and so only asked R to save the value, not print it to the console."),
    answer("No", correct = TRUE, message = "Correct, this command used the assignment operator, and so only asked R to save the value, not print it to the console."),
    allow_retry = TRUE
  ),

  question("How can you know the number of total cases (check all that apply)?",
    answer("Look at the value of total_cases in the Environment",
           correct = TRUE),
    answer("Yell at R until it tells me",
           correct = FALSE),
    answer("Run a command of only total_cases, to print its current value",
           correct = TRUE),
    allow_retry = TRUE
  ),

  question("What is the number of total cases?",
    answer("34",
           message = "You have selected the number of CONFIRMED cases only"),
    answer("12",
           message = "You have selected the number of SUSPECT cases only"),
    answer("46",
           correct = TRUE,
           message = "You have successfully selected the total number of cases"),
    allow_retry = TRUE
  )
)

Redéfinir les objets

Que se passe-t-il si tu reçois la nouvelle qu'il y a 10 cas supplémentaires confirmés ?

Si tu modifie la première commande pour qu'elle se lise confirmed_cases <- 44 la valeur de confirmed_cases dans le panneau Environnement de RStudio immédiatement passe immédiatement à 44 ? (Non.) Est-ce que la valeur de total_cases passe immédiatement à 56? (Aussi No.)

quiz(
   question_checkbox("Select all the steps that must happen for the value of total_cases to be updated to 56?",
    answer("Run the command: confirmed_cases <- 44",
           message = "Yes, first the confirmed_cases must be re-defined",
    correct = T),
    answer("Re-run the command: total_cases <- confirmed_cases + suspect_cases",
           message = "Yes, second, the total must be updated with the new number of confirmed cases",
    correct = T),
    answer("Give your course instructor a gift",
           message = "No, bribing your course instructor will not make R do magic."),
    allow_retry = TRUE
  )
)

Si tu modifies une valeur écrite dans ton script, cela n'a pas d'effet. ne met pas automatiquement à jour le reste de ton script, et ne modifie pas non plus les valeurs stockées dans R !

Tu dois réexécuter les commandes pour que les changements soient enregistrés par R.

Dans ce cas, tu dois réexécuter deux commandes pour mettre à jour la valeur de total_cases (et elles doivent être exécutées dans le bon ordre !)

Exécution de plusieurs lignes

Tu te demandes peut-être : "Pourquoi dois-je exécuter chaque ligne de mon script une par une ?". Eh bien, ce n'est pas nécessaire ! Utilise ta souris pour mettre en évidence plusieurs commandes dans le script et les exécuter.

Avant d'exécuter plusieurs lignes, Vérifie qu'il n'y a pas de code inachevé qui pourrait provoquer une erreur. N'oublie pas que R s'arrête s'il rencontre une erreur.

Le symbole # peut également être utilisé pour temporairement désactiver un code. S'il est placé en début de ligne, R ignorera ce code.

# Example of a line being deactivated with a # symbol
confirmed_cases <- 44
suspect_cases <- 12
#cases_with_status_pending <- 3

total_cases <- confirmed_cases + suspect_cases

Exercice : Calcul de la chaîne d'approvisionnement médicale

Appliquons ce que tu as appris à l'exemple de chaîne d'approvisionnement de la section précédente. Pour rappel : tu gères les fournitures du test COVID-19 sur 3 sites. Tu disposes des informations suivantes :

• Le site 1 a besoin de 200 tests
• Le site 2 a besoin de 550 tests
• Le site 3 a 2 sous-sites qui ont chacun besoin de 925 tests.
• Tu devrais commander 10 % de plus pour faire face à une demande plus importante.
• Il te reste 420 tests supplémentaires du mois dernier, que tu peux utiliser pour le mois à venir.

Plus tôt, tu as écrit cette commande pour calculer le nombre de tests nécessaires :

((200 + 550 + (925 * 2)) * 1.1) - 420

Réécris ce calcul en utilisant objets afin qu'il puisse être facilement mis à jour chaque mois.

r fontawesome::fa("lightbulb", fill = "gold") Cliquez pour lire un indice

.

Commence par écrire 3 commandes, qui définissent les besoins pour chacun des 3 sites.

Ensuite, écris une commande qui définit les tests excédentaires restants du mois précédent.

Enfin, écris une commande qui imprime le nombre total de tests nécessaires en remplaçant les nombres par les noms d'objets définis dans les commandes précédentes.

r fontawesome::fa("check", fill = "red")Cliquez pour voir une solution (essayez-la d'abord vous-même !)

.

# define values (objects) for use in the calculation
site1 <- 200
site2 <- 550
site3 <- 925 * 2
extra <- 420

# run this command to print the amount needed to order
((site1 + site2 + site3) * 1.1) - extra

Maintenant que tu as configuré ton calcul pour qu'il soit facile à calculer, utilise le code que tu as créé pour répondre à la question suivante :

quiz(
   question("How many tests should you order if site 1 needs 250, site 2 needs 730, site 3's two sites need 1050 each, and you have 37 extra from the previous month?",
    answer("3253", message = "Check your parentheses - is 1.1 multiplied on ALL of the sites, as it should be?"),
    answer("3351", correct = TRUE, message = "Nice work!"),
    answer("2980", message = "You have made an incorrect calculation, check your code against the solution"),
    allow_retry = TRUE
  )
)

Réfléchis, comment répondrais-tu aux questions suivantes ?

• Si tu voulais enregistrer la valeur de sortie finale pour la référencer plus tard, quel opérateur ajouterais-tu, et où ?
• Comment devrais-tu modifier ton script si les deux sous-sites du site 3 avaient besoin d'un nombre différent de tests ?

Si tu n'es pas sûr, demande à un instructeur.

r fontawesome::fa("exclamation", fill = "red") N'oublie pas de sauvegarder souvent ton script R ! Clique simplement sur la petite "icône de sauvegarde" dans la rangée d'icônes au-dessus du script, ou clique sur Fichier -> Enregistrer

Commentaire

Tu as maintenant écrit un script utile ! Mais un collègue pourra-t-il comprendre ta logique et tes commandes ?

Utiliser le # (dièse) pour les commentaires

Comme nous l'avons démontré plus haut, tout texte écrit dans le champ droite du symbole de hachage est ignoré par R. Tu peux placer le symbole de hachage :

• Ecris un commentaire sur une ligne entière - par exemple, écris une section de métadonnées informatives en haut de ton script :

# Purpose: Calculate monthly order for testing supplies
# Author: (your name)
# Last updated: (date)  
# Contact email: (your email)

# define values (objects) for use in the calculation
site1 <- 200         
site2 <- 550         
site3 <- 925 * 2     
extra <- 420         

# run this command to print the amount needed to order
((site1 + site2 + site3) * 1.1) - extra

• Tu peux aussi écrire des commentaires sur la même ligne que le code, avec un # placé à la fin de la ligne. gauche du code :

# Purpose: Calculate monthly order for testing supplies
# Author: (your name)
# Last updated: (date)  
# Contact email: (your email)

# define values (objects) for use in the calculation
site1 <- 200         # needs for site 1
site2 <- 550         # needs for site 2 
site3 <- 925 * 2     # needs for site 3 subsites
extra <- 420         # number of tests remaining from last month

# run this command to print the amount needed to order
((site1 + site2 + site3) * 1.1) - extra

Tu trouveras ci-dessous un exemple de script bien documenté qui importe des données et effectue des analyses épidémiologiques de base. Tu n'as PAS besoin d'écrire ce code dans ton script - il te suffit de. Note à quel point il est facile à lire - chaque section est clairement notée avec beaucoup d'espaces et de nouvelles lignes entre les portions de code.

knitr::include_graphics("images/example_script.png", error = F)

Titres des sections

Les en-têtes de section sont un moyen utile d'organiser ton code. Tu peux utiliser un raccourci clavier pour insérer un en-tête de section dans ton script.

Place ton curseur à l'endroit où la nouvelle section doit commencer et appuie sur Ctrl, Shift et R en même temps (ou Cmd Shift R sur Mac) Dans la fenêtre contextuelle, nomme la section, par exemple "Besoins mensuels en fournitures".

L'en-tête de la nouvelle section doit ressembler à ceci :

# Monthly supply needs ----------------------------------------------

RStudio reconnaîtra cette section, et elle apparaîtra dans le script "Outline", situé en haut à droite du panneau de script R. Cet outil cliquable Outline peut être très utile pour naviguer dans des scripts comportant des centaines, voire des milliers de lignes.

knitr::include_graphics("images/section_headings.png", error = F)

Adapte ton script pour utiliser les titres de section et les commentaires.

r fontawesome::fa("check", fill = "red")Cliquez pour voir une solution (essayez-la d'abord vous-même !)

.

# About this script ----------------------------------------------
# Purpose: Calculate monthly order for testing supplies
# Author: (your name)
# Last updated: (date)  
# Contact email: (your email)


# Monthly supply needs ----------------------------------------------
# You can change these numbers to reflect the expected needs for each site

site1 <- 200         # needs for site 1
site2 <- 550         # needs for site 2 
site3 <- 925 * 2     # needs for site 3 subsites
extra <- 420         # number of tests remaining from last month


# Calculation ----------------------------------------------
# Note: This equation includes a 10% buffer, via the 1.1 factor

((site1 + site2 + site3) * 1.1) - extra

Objets des personnages

Les objets peuvent également contenir des valeurs "caractères" (texte, mots). Ceux-ci sont placés entre guillemets, comme "New York City" ou "dm76wk34" (un identifiant unique de cas généré de façon aléatoire).

Note que les objets caractères peuvent être créés avec des "guillemets doubles" ou des "guillemets simples" pour le même effet (il peut être utile de placer des guillemets simples dans des guillemets doubles parfois).

Lorsque ton script R reconnaît que ce que tu as écrit est une valeur de caractère (une fois que le premier et le dernier guillemet sont écrits), il prend une couleur différente.

name <- "Oliver"
district <- "Bolo"
occupation <- "nurse"

Essaie de définir quelques objets caractères dans ton script, comme ceux ci-dessus. Essaie de les imprimer sur la console et de modifier leur valeur.

Note que trente-quatre pourrait être écrit en R comme :

• 34 (une valeur numérique, capable d'être utilisée dans des calculs mathématiques), ou
• "34" (une valeur de caractère, ne pouvant pas faire l'objet de calculs).

Que se passe-t-il si tu essaies d'ajouter 30 + "12" ?

Nous utiliserons d'autres objets de caractère dans la section suivante...

Fonctions

Les exemples précédents d'exécution de commandes, de création d'objets et de calculs mathématiques ne mettent pas en valeur les meilleures capacités de R.

La véritable puissance de R provient de *fonctions*! Les fonctions sont au cœur de l'utilisation de R et te permettent d'effectuer des tâches plus complexes.

Une fonction est comme une machine

Une fonction reçoit des entrées fait quelque chose action avec ces données et produit une sortie. La nature de la sortie dépend de la fonction.

Les fonctions opèrent sur un objet placé entre les parenthèses de la fonction. Par exemple, la fonction sqrt() renvoie la racine carrée d'un nombre :

sqrt(64)

De même, la fonction sum() accepte un nombre illimité de valeurs numériques et renvoie la somme.

sum(2, 5, 10, -8, 100)

Dans ton script R, utilise les fonctions min() et max() pour trouver le minimum et le maximum des nombres 3, 55, 9, -4 et 33.

Nous ne ferons pas de quiz, car les réponses devraient être assez faciles... mais ton code a-t-il fonctionné ?

# calculate the minimum value
min(3, 55, 9, -4, 33)

# calculate the maximum value
max(3, 55, 9, -4, 33)

Création de vecteurs avec la fonction c()

Essayons la fonction c(). Le "c" représente le terme "concaténer" (tu peux t'en souvenir comme "combine"), car cette fonction combine les valeurs entre parenthèses en une seule unité.

Nous appelons l'unité produite par c() a vecteur. Un vecteur est une unité de plusieurs valeurs, qui doivent être de la même classe (soit toutes numériques, toutes de caractères, toutes logiques, etc. doivent être séparés par des virgules.

Vois cet exemple, où nous créons un tableau nommé de valeurs numériques (les âges de 5 patients).

# create a vector of patient ages
patient_ages <- c(5, 10, 60, 25, 12)

Essaie la commande ci-dessus dans ton script R. Maintenant, que se passe-t-il lorsque tu exécutes la commande patient_ages? Tous les nombres s'impriment sur la console R.

Il est utile que ces nombres puissent être référencés par un seul nom, car nous pouvons maintenant appliquer des modifications à tous ces nombres en une seule étape :

patient_ages * 2

Je ne sais pas trop pourquoi nous devrions multiplier tous les âges des patients par 2, mais c'était facile, n'est-ce pas ? !

Fonctions qui modifient leur contenu

Essaie de créer ton propre vecteur - Crée un vecteur de quelques noms de districts/villes/communes de ta région. Nomme-le jurisdictions. Ta commande ressemble-t-elle à ceci ?

# A character vector of jurisdiction names in Mozambique  
jurisdictions <- c("Maputo", "Inhambane", "Gaza", "Zambezia", "Manica", "Sofala")

Que peut-on faire avec un caractère vecteur de caractères ? Nous ne pouvons pas le multiplier par 2... Pour t'amuser, laisse-nous plaçons ce vecteur dans une autre fonction: toupper(), qui transforme tous les caractères en majuscules :

toupper(jurisdictions)

Remarque : même si le vecteur contient des valeurs de caractères, lorsqu'on tape le mot clé nom de l'objet ou nom du vecteur, tu n'utilises pas de guillemets. C'est un objet R, tout comme confirmed_cases et doit donc être écrit en clair dans le code.

À quoi ressemble la sortie ? Et si tu essayais la fonction tolower()? Cela pourrait être utile pour normaliser les noms ou d'autres mots de caractères lorsque l'on joint deux ensembles de données !

quiz(
  question("Was this toupper() command a PRINTING command, or a SAVING command?",
    answer("Printing",
           message = "Yes, There is no arrow operator. The values in the jurisdictions object were only changed temporarily in order to print them in UPPER CASE to the Console. The values were not changed in the Environment.",
           correct = TRUE),
    answer("Saving",
           message = "No, there was no arrow used, and the values in the jurisdictions object were not actually changed."),
    allow_retry = TRUE
  ) 
)

Fonctions avec arguments nommés

La plupart des fonctions que tu rencontreras dans R ont des arguments nommés. Ceux-ci te permettent de spécifier les paramètres selon lesquels la fonction fonctionnera.

# adding xfun::relative_path() creates a dynamic file path between the Rmd location and the here() path.
# It dynamically creates the ../../etc filepath.

knitr::include_graphics("images/arguments-buttons.png", error = F)

Revenons au vecteur de caractères jurisdictions que tu as défini plus tôt. Ton vecteur peut inclure d'autres juridictions locales à ton domicile.

jurisdictions

Imagine que tu veuilles imprimer ces noms de juridictions dans un rapport (oui, tu peux automatiser des rapports avec R !), mais ce résultat est laid et n'est pas très lisible dans une phrase. Tu veux peut-être des virgules entre les noms.

La fonction paste() accepte des valeurs et les combine.

• Le premier argument de paste() est le nom de l'objet contenant les valeurs que tu veux combiner. Pour cet exemple, nous utiliserons l'objet jurisdictions que nous avons créé.

• paste() a un autre argument qui est nommé collapse = qui insère un élément ou un symbole (par exemple un espace ou une virgule, ou les deux !) entre chacune des valeurs.

Arguments sont rédigés entre les parenthèses de la fonction avec un seul signe égal Nous nous référons donc à la fonction collapse comme collapse =. Note que les arguments sont séparés par des virgules à l'intérieur de la fonction.

Ecris le code suivant dans ton script et exécute la commande dans ta console pour voir le résultat :

paste(jurisdictions, collapse = ",")

Comprenons bien ce qui se passe :

1) Le premier argument attend le nom d'un vecteur, dans ce cas : les juridictions. Souvent, le premier argument d'une fonction est une donnée à exploiter, et n'a pas besoin d'un nom ni d'un signe égal.

2) Le deuxième argument est collapse =, auquel on fournit une valeur de caractère (entre guillemets) devant apparaître entre chacun des mots. Dans l'exemple ci-dessus, nous avons choisi une virgule : ",".

paste(juridictions, collapse = ",")

Le résultat ressemble à ceci :

paste(jurisdictions, collapse = ",")

Réplique le code ci-dessus avec ton jurisdictions dans RStudio. Note que cette fonction sait qu'il ne faut pas placer de virgule après la dernière valeur de jurisdictions.

Comment ajusterais-tu le code pour ajouter un espace après chaque virgule ?

r fontawesome::fa("check", fill = "red")Cliquez pour voir une solution (essayez-la d'abord vous-même !)

.

# Note the space after the comma, within the quotation marks
paste(jurisdictions, collapse = ", ")

Arguments facultatifs et valeurs par défaut

Les fonctions ont souvent de nombreux arguments, et tous ne sont pas nécessaires pour qu'elles s'exécutent. Dans le paste() exercice ci-dessus, collapse = est facultatif. Tu peux utiliser la fonction sans lui spécifier de valeur.

Dans un autre exemple, les fonctions qui font des tracés ont des arguments comme title =, subtitle =, color =, etc. Tu n'as pas besoin de fournir des valeurs pour que la fonction s'exécute avec succès.

Les codeurs R n'ont pas un cerveau encyclopédique - nous recherchons ces informations tout le temps dans la documentation d'aide ou dans des ressources telles que notre site Web. Manuel de l'épidémiologiste R.

Obtenir de l'aide

Les arguments d'une fonction et toutes les valeurs par défaut peuvent être lus dans la fenêtre d'aide de la fonction. documentation. Pour lire la documentation, recherche le nom de la fonction dans la rubrique volet d'aide en bas à droite de RStudio. Tu peux aussi taper ? avant le nom de la fonction dans la fenêtre d'aide de RStudio. Console (par exemple, ?paste).

Les détails de la documentation ressembleront à ceci (nous pouvons t'aider à les interpréter, car ils peuvent être difficiles à comprendre au début) :

knitr::include_graphics("images/r_documentation.png", error = F)

quiz(
  question("What are the arguments in the following command:\n\nage_pyramid(data = linelist, split_by = 'gender', age_group = 'agecat5', proportional = TRUE)",
    answer("linelist, split_by, age_group, proportional", message = "Careful! linelist comes after an equals sign. It is the value assigned to the argument data = "),
    answer("data, split_by, age_group, proportional", correct = T),
    answer("age_pyramid, linelist, 'gender', proportional", message = "age_pyramid is the function, and linelist is the value assigned to the argument data = "),
    allow_retry = T
  )
  )

quiz(
  question("All R functions have multiple arguments that require input",
    allow_retry = T,
    answer("True"),
    answer("False", correct = TRUE, message = "Not all functions have multiple arguments, and typically for functions with multiple arguments, many have default values that do not need to by supplied.")
  )
)

Fonctions mathématiques de base R

Passe brièvement en revue ces autres opérateurs et base R de base.

| Objectif | Fonction | | --------------------------- | ------------------------------------- | | arrondi | round(x, digits = n) | | arrondir | janitor::round_half_up(x, digits = n) | | valeur absolue | abs(x) | | racine carrée | sqrt(x) | | exposant | exposant(x) | | logarithme naturel | log(x) | | log base 10 | log10(x) |

Note : Voir cette page dans le manuel Epi R avant d'utiliser les fonctions d'arrondi. Il existe une nuance mathématique qui est importante dans certaines circonstances.

Fonctions statistiques

Passe brièvement en revue ces fonctions statistiques courantes dans R. Nous les utiliserons fréquemment.

| Objectif | Fonction | | --------------------------- | ------------------------------------- | | mean (moyenne) | mean(x, na.rm=T) | | médiane | median(x, na.rm=T) | | écart-type | sd(x, na.rm=T) | | quantiles* | quantile(x) | | somme | sum(x, na.rm=T) | | valeur minimale | min(x, na.rm=T) | | valeur maximale | max(x, na.rm=T) | | plage de valeurs numériques | range(x, na.rm=T) | | résumé | résumé(x) |

ATTENTION : Par défaut, toutes les valeurs manquantes dans le calcul (écrites dans R sous forme de NA) se traduira par un résultat de NA à moins que l'argument na.rm = ne prenne la valeur TRUE qui supprime (rm) les NA du calcul. On peut l'écrire de façon abrégée sous la forme na.rm = T. Cela aura plus de sens lorsque nous commencerons à utiliser des ensembles de données.

[DANGER : Si tu fournis un vecteur autonome de nombres à l'une des fonctions statistiques ci-dessus, assure-toi d'entourer les nombres de c() .]{style="color: red;"}

# If supplying raw numbers to a statistical function, wrap them in c()
mean(1, 6, 12, 10, 5, 0)    # !!! INCORRECT !!!  

mean(c(1, 6, 12, 10, 5, 0)) # CORRECT

Paquets

Jusqu'à présent, tu as utilisé {base} les fonctions R que sont installées avec R tels que sum(), c() et min(). Ces fonctions ne représentent qu'une infime partie de toutes les fonctions R.

Une paquetage R est un ensemble partageable de fonctions apparentées que tu peux télécharger et utiliser.

Les paquets ont généralement un thème, par exemple :

• Le {stringr} fournit des fonctions permettant de travailler avec des "chaînes" (valeurs de caractères).
• Le paquet {lubridate} fournit des fonctions qui facilitent le travail avec les dates.
• L'ensemble {epikit} fournit des fonctions utiles à l'analyse épidémiologique

Les noms des paquets sont souvent écrits dans le texte avec des crochets. { }. Ce n'est pas le cas lorsque tu écris les noms des paquets dans ton code R.

Les noms sont aussi souvent des jeux de mots intelligents - l'esprit ludique de la communauté R est évident !

CRAN

Pour installer la plupart des paquets R, utilise les commandes R pour télécharger le paquet depuis le "CRAN" vers la "bibliothèque R" de ton ordinateur.

De nombreux utilisateurs de R créent des fonctions spécialisées qu'ils partagent avec la communauté R sous forme de paquets. Pour que les paquets soient largement distribués, ils sont généralement partagés sur le site Comprehensive R Archive Network (CRAN) qui est le dépôt central de logiciels R - une archive de paquets R qui ont passé un examen de base.

En décembre 2023, il y a 20 190 paquets disponibles sur le CRAN. Certains d'entre eux sont immensément populaires, avec des centaines de milliers de téléchargements chaque mois.

Sécurité et VPN

Tu t'inquiètes des virus et de la sécurité lorsque tu télécharges un paquet sur le CRAN ? Lire cet article sur le sujet.

Si tu utilises un réseau privé virtuel (VPN), il se peut que tu doives le désactiver pour pouvoir installer les paquets R.

Installer et charger les paquets

Une fois qu'un paquet est installé il est stocké dans ta "bibliothèque" R. Tu peux ensuite accéder aux fonctions qu'il contient en "chargeant" le paquet pour l'utiliser pendant la session R en cours .

En résumé : pour utiliser les fonctions disponibles dans un paquet R, 2 étapes doivent être mises en œuvre :

1. Le package doit être installé (une fois), et
2. Le paquet doit être chargé (à chaque nouvelle session R, à chaque fois que nous rouvrons RStudio)

Considère R comme ta bibliothèque personnelle : lorsque tu installes un paquetage, ta bibliothèque s'enrichit d'un nouveau "livre" de fonctionsMais chaque fois que tu veux utiliser une fonction de ce livre, tu dois l'emprunter ("charger") dans ta bibliothèque.

knitr::include_graphics("images/bookshelf1.png", error = F)

Commandes pour installer les paquets R

Notre premier conseil est le suivant : écris ton code qui installe et charge les paquets en haut du script. (en tant que première commande).

Cela te permet, ainsi qu'aux autres lecteurs, de savoir clairement quels paquets sont nécessaires à l'exécution du script.

{base} Commandes R

Il existe {base} R pour installer et charger les paquets. Elles ne constituent pas l'approche la plus efficace, mais tu peux toujours revenir à cette méthode.

Étape 1 : Installer un paquet avec {base} R

install.packages() est la {base} R pour installer des paquets (note que "paquets" est écrit au pluriel). Écris le nom du paquet entre parenthèses, entre guillemets. Les noms de paquets sont sensibles à la casse.

# install the janitor package with base R
install.packages("janitor")

r fontawesome::fa("exclamation", fill = "red") Note que cette commande installera le paquetage à chaque fois qu'elle est exécutée - même si le paquet est déjà installé. De plus, elle ne charger le paquet pour l'utiliser dans la session en cours (étape 2 ci-dessus).

Si tu veux installer plusieurs paquets en une seule commande, ils doivent être listés dans un vecteur de caractères c().

# install multiple packages with base R
install.packages(c("janitor", "rio", "here"))

Essaie maintenant : écris une commande en haut de ton script pour installer le paquetage "pacman" Si une fenêtre pop-up te demande si tu veux redémarrer R, dis "Non".

r fontawesome::fa("check", fill = "red")Cliquez pour voir une solution (essayez-la d'abord vous-même !)

.

install.packages("pacman")

Étape 2 : Charge un paquet avec {base} R

Te souviens-tu du nombre de fois où tu dois charger un paquet ? Chaque fois que tu démarres R.

Tu peux le faire en utilisant le {base} fonction R library().

Ecris et exécute la commande suivante sous le install.packages("pacman") que tu viens d'ajouter à ton script.

# Loads the package pacman for use in the current R session
library(pacman)

Les fonctions de la commande {pacman} sont maintenant disponibles.

Les {pacman} approche

Le paquet "pacman" t'aide efficacement installer et charger d'autres paquets et facilite grandement le partage des scripts R entre collègues. Son nom fait référence à "package hommeager" (pas le personnage du jeu vidéo !)

Son p_load() effectue les étapes 1 et 2 de manière efficace. Il installe chaque paquet uniquement s'il n'est pas déjà installé. En outre, il charger chaque paquet pour l'utiliser.

La syntaxe est très simple. Place les noms des paquets entre les parenthèses, séparés par des virgules. Les guillemets ne sont pas nécessaires. Les noms de paquets sont sensibles à la casse.

Ecris cette commande en tête de ton script, en tant que première commande, et exécute-la. Place un # devant chaque install.packages() et library pour qu'elles soient désactivées.

pacman::p_load(rio, here, janitor, tidyverse)

Lorsque ton collègue exécute cette commande sur son ordinateur, seuls les paquets qu'il n'a pas encore sur son ordinateur seront installés, et tous seront chargés. Cela utilise moins de lignes de code et n'entraîne pas d'installations inutiles. Il faut pour cela que ton collègue ait le fichier {pacman} soit déjà installé,

La syntaxe spéciale pacman::p_load() utilise deux points de suspension : : pour relier explicitement le nom du paquet pacman et le nom de la fonction p_load(). Cette syntaxe est utile car elle charge le {pacman} (en supposant qu'il soit déjà installé), ce qui évite d'avoir recours à l'option libary(pacman). C'est l'une des rares fois où la syntaxe : : est utile.

IMPORTANT : Fais en sorte que ton pacman::p_load() commande ne soit écrite que une fois vers le haut de ton script. Si tu réalises plus tard que tu as besoin de paquets supplémentaires, ajoute-les simplement à cette commande et réexécute-la.

Documentation

Dans toute commande R, les nouvelles lignes et l'indentation n'auront pas d'impact sur l'exécution du code mais peuvent améliorer considérablement la lisibilité !

Par conséquent, la commande pacman peut être écrite verticalement, avec des commentaires pour expliquer pourquoi nous chargeons des paquets spécifiques.

Modifie ta commande pour qu'elle ressemble à ceci.

# Load all the packages needed, installing if necessary
pacman::p_load(
     rio,          # for importing data
     here,         # for file paths
     janitor,      # for data cleaning
     tidyverse     # for data management
)

Il est généralement conseillé de lister les {tidyverse} en dernier, en raison d'un phénomène appelé "masquage de fonction". Demande à un instructeur si tu veux en savoir plus.

quiz(caption = "Quiz - packages",
  question("How often do you need to install a package on your computer?",
    allow_retry = T,
    answer("Every time you restart R", message = "Packages only need to be installed once. There is no relation to restarting R."),
    answer("Only once", correct = TRUE, message = "Packages must be installed once. After a long time, you may want to update them by re-installing."),
    answer("Never (assuming you are connected to the internet)", message = "Packages must be installed once. You can not access them dynamically through the internet."),
    answer("Each time you restart your computer", message = "Packages only need to be installed once. There is no relation to restarting your computer.")
  ),

  question("How often do you need to load a package?",
    allow_retry = T,
    answer("Every time you start or restart R", correct = TRUE, message = "Packages must be loaded each time you start an R session."),
    answer("Only once", message = "Packages must be installed only once, but must be loaded at the beginning of each R session."),
    answer("Never (assuming you are connected to the internet)", message = "Packages must be installed once and loaded at the beginning of each R session. You can not access them dynamically through the internet."),
    answer("Each time you restart your computer", message = "Packages only need to be installed once and loaded at the beginning of each R session. There is no relation to restarting your computer.")
  ),

  question("Newlines and indents can be used to improve readability without impacting code execution.",
    allow_retry = T,
    answer("True", correct = TRUE),
    answer("False")
  ),

  question("The pacman function p_load() does which of the following (select ALL that apply).",
    allow_retry = T,
    answer("Installs the packages if it is not yet installed", correct = TRUE),
    answer("Loads the packages for use", correct = TRUE),
    answer("Produces a small yellow pacman emoji that eats your code line-by-line")
  )
)

Importer un jeu de données

Commençons à travailler avec des données ! Pour travailler avec un ensemble de données enregistré sur ton ordinateur sous forme de fichier Excel, CSV ou autre, tu dois importer dans l'environnement R en tant qu'objet.

L'ensemble de données sera sauvegardé en tant que cadre de données qui se compose de colonnes et de lignes.

Contrairement à d'autres logiciels, R peut stocker plusieurs ensembles de données à la fois.

Emplacement des données

Pour importer un ensemble de données dans R, tu dois indiquer à R où accéder au fichier sur ton ordinateur (par exemple, un dossier spécifique) Cela peut parfois s'avérer étonnamment difficile.

Cependant, en utilisant un projet RStudio et enregistrer les données dans le projet Le processus devient alors beaucoup plus facile.

Dans le répertoire du projet "module1", vérifie que le dossier "de premier niveau" ou "racine" du projet (dans lequel se trouve l'icône "module1.Rproj") contient le fichier "testing_data.csv". Nous allons importer cet ensemble de données dans notre session R actuelle.

knitr::include_graphics("images/data_in_root.png", error = F)

{rio} - le paquet facile pour importer des données

Il y a {base} R pour importer des données, mais elles peuvent être déroutantes et difficiles à mémoriser. Par exemple, il existe des fonctions distinctes pour importer différents types de fichiers dans R (par exemple, .xlsx, .csv, .tsv, .txt, etc).

Heureusement, il existe une fonction qui fonctionne pour presque tous les formats de fichiers Il s'agit de la fonction import() du paquet {rio}.

Les import() s'attend à recevoir une valeur de caractère - le chemin d'accès au fichier des données que tu souhaites importer. Dans ce cas, notre fichier de données est enregistré dans le dossier racine du projet RStudio, il te suffit donc de fournir le nom et l'extension du fichier, entre guillemets, comme ci-dessous :

import("testing_data.csv")

Crée une nouvelle section de script, en utilisant le raccourci Ctrl + Shift + R, et nomme-la "Pratique de l'importation de données"

Tape et exécute le script import() ci-dessus dans la section "S'entraîner à importer des données" de ton script.

r fontawesome::fa("exclamation", fill = "red") As-tu vu cette erreur ?

Erreur dans import("testing_data.csv") : impossible de trouver la fonction "import".

Si c'est le cas, cela signifie que tu n'as pas installé et chargé le fichier {rio} Si c'est le cas, cela signifie que tu n'as pas installé et chargé le paquetage. Si tu as besoin d'aide, revois la section précédente et cherche l'icône pacman::p_load() qui charge plusieurs paquets, y compris {rio}.

Une fois que la commande s'est exécutée avec succès, tu as probablement vu beaucoup de texte apparaître dans la Console. C'était le jeu de données !

Réfléchis : qu'est-ce que ton commandement a demandé à R de faire ? Était est un IMPRIMER ou une commande SAUVEGARDE ou une commande d'ÉCONOMIE ?

...Tu as demandé à R d'importer l'ensemble de données... et comme il n'y avait pas de <- (opérateur d'affectation) dans la commande, l'action par défaut a été de imprimer la sortie dans la console.

Maintenant, ajuste ta commande pour qu'elle soit enregistrer l'ensemble de données en tant qu'objet dans ton Environnement, avec le nom tests?

r fontawesome::fa("lightbulb", fill = "gold") Cliquez pour lire un indice

.

Utilise l'opérateur d'affectation <- avant la fonction. N'oublie pas les guillemets autour du nom du fichier.

r fontawesome::fa("check", fill = "red")Cliquez pour voir une solution (essayez-la d'abord vous-même !)

.

tests <- import("testing_data.csv")

Lorsque tu exécutes ce code, tu devrais voir le nouvel objet tests apparaître dans le volet Environnement, avec une courte description du nombre d'observations et de variables. Félicitations, tu as maintenant importé un ensemble de données dans R ! Bravo !

Regarde l'ensemble de données

Maintenant que tu as importé les données, jette un coup d'œil !

Dans le volet Environnement, clique une fois sur le cercle bleu à côté du nom du jeu de données.

La zone développée sous le nom est une vue d'ensemble des colonnes du cadre de données. Il y a également une abréviation qui indique la "classe" de la colonne (caractère, entier, etc.) et les premières valeurs de la colonne. C'est passionnant !

Pour afficher l'ensemble des données, clique sur le nom de l'objet test dans le volet Environnement Cela ouvre un nouvel onglet affichant le cadre de données, dans le volet situé à côté du script R.

Entraîne-toi à faire défiler le cadre de données et à appliquer des filtres (voir l'icône de filtre en haut à gauche de l'affichage des données).

quiz(caption = "Quiz - data review",
  question("How many columns are there in the data frame?",
    allow_retry = T,
    answer("665", message = "No, this is the number of rows/observations"),
    answer(ncol(tests), correct = TRUE, message = "Yes this is correct!"),
    answer("4", message = "This is not correct, try again."),
    answer("25", message = "No, this is the number of rows shown in the initial display")
  ),

  question("What is the value in the 4th column and the 10th row?",
    allow_retry = T,
    answer(tests[10, 4], correct = TRUE),
    answer("899"),
    answer("38.3"),
    answer("Site 3")
  ),

  question("How many of the rows include between 100 and 300 tests requested (inclusive)?",
    allow_retry = T,
        answer("14"),
        answer(tests %>% filter(tests_requested >= 100 & tests_requested <= 300) %>% nrow(), correct = TRUE),
        answer("20"),
        answer("4")
  )
)

Si tu as du mal à répondre à la dernière question, clique sur la case blanche en dessous de "tests_requested" pour filtrer la colonne numériquement, puis lis le résumé des lignes filtrées en bas du volet. Note que cette action est pas filtrer la base de données réelle, mais seulement ta vue temporaire de la base de données.

Explore ton jeu de données

Profitons de cette occasion pour explorer l'ensemble de données.

Ajouter des paquets

Va dans ton pacman::p_load() en haut de ton script et ajoute ces paquets à la liste. Ajoute-les avant le paquet "tidyverse", et n'oublie pas de mettre des virgules !

• skimr
• flexible
• échelles
• gtsummary

Ta commande devrait maintenant ressembler à ceci :

# Load all the packages needed, installing if necessary
pacman::p_load(
     rio,          # for importing data
     here,         # for file paths
     janitor,      # for data cleaning
     skimr,        # for exploratory analysis
     flextable,    # for formatting tables
     scales,       # for formatting values
     gtsummary,    # for pretty tables
     tidyverse     # for data management
)

Clique pour placer ton curseur n'importe où dans le pacman::p_load() dans ton script R et réexécute la commande en cliquant sur Exécuter ou en appuyant sur la touche Entrée de ton clavier.

Résumer tes données

Les {skimr} paquet

Tu peux obtenir un résumé utile de l'ensemble de données à l'aide du paquet R {skimr} et sa fonction skim().

Tu devrais avoir déjà installé et chargé {skimr} en l'ajoutant à ton pacman::p_load() et en réexécutant cette commande. Si tu rencontres des erreurs, préviens ton animateur.

Retourne à la section "S'entraîner à importer des données" de ton scriptPlace le nom de ton objet cadre de données importé (tests) dans le champ skim() et exécute la commande. Quel contenu apparaît dans la console R ?

Si la sortie n'est pas facilement lisible, élargis ton volet Console en déplaçant les limites entre les volets de RStudio (double-clic et glissement), puis exécute à nouveau la commande.

r fontawesome::fa("check", fill = "red")Cliquez pour voir une solution (essayez d'abord vous-même !)

.

skim(tests)

Que montre la sortie ?

quiz(caption = "Quiz - reviewing the data",
  question("How many columns has R classified as numeric?",
    allow_retry = T,
    answer("12", message = "No, this is more than the columns in the dataset!"),
    answer(tests %>% select(where(is.numeric)) %>% ncol(), correct = TRUE, message = "Yes this is correct!"),
    answer("1", message = "No, this is the number of columns that are POSIXct - a type of date format")
  ),

  question("Review the information on the character columns. How many unique values are in the sites column?",
    allow_retry = T,
    answer(length(unique(tests$site)), correct = TRUE),
    answer("6"),
    answer("12"),
    answer("0")
  ),

  question("Review the information on numeric columns. What is the median (50th percentile) of monthly tests requested?",
    allow_retry = T,
        answer("32.2"),
        answer(median(tests$tests_requested, na.rm=TRUE), correct = TRUE),
        answer("1250"),
        answer("99.0")
  )
)

Autres fonctions de résumé

Il existe d'autres {base} R disponibles pour résumer des objets, comme par exemple :

summary()
glimpse()

Essaie ces autres fonctions sur ton cadre de données. Compare les résultats de chaque fonction. Quel résultat préfères-tu ?

Indexation pour extraire des colonnes ou des cellules spécifiques

Dans une question précédente du quiz, nous t'avons demandé de trouver la valeur dans la 4e colonne, et la 10e ligne. Au lieu de chercher manuellement, tu peux aussi écrire du code pour isoler et visualiser des morceaux du cadre de données.

L'extraction d'une colonne à l'aide de la fonction $ opérateur d'indexation

"Indexer" signifie faire référence à une seule partie d'un objet. L'opérateur $ est un opérateur {base} R pour extraire une seule colonne d'une base de données. Ecris le nom de la base de données, puis $ puis le nom de la colonne, comme indiqué ci-dessous.

Ajoute le code suivant à ton script R pour imprimer une seule colonne de tests:

tests$tests_requested

Colonnes en tant que vecteurs

Voici quelque chose que tu dois savoir : les colonnes sont des "vecteurs" - une longue ligne de valeurs de la même classe, tout comme jurisdictions et patient_ages que tu as vus plus tôt dans ce module. En fait, une base de données est simplement une collection de vecteurs (colonnes !).

Tout comme tu as placé les vecteurs jurisdictions dans la fonction toupper() tu peux aussi placer une colonne dans une fonction. Par exemple :

Nous pouvons utiliser la fonction mean() pour obtenir la moyenne d'une colonne. Essaie ceci dans ton script R :

mean(tests$tests_requested)

Nous pouvons utiliser la fonction summary() pour résumer les informations relatives à une colonne. Essaie ceci dans ton script R :

summary(tests$tests_requested)

Pendant que tu tapais, lentement, as-tu vu apparaître un petit menu qui montrait toutes les colonnes du cadre de données ? Tu peux cliquer pour sélectionner une colonne dans le menu déroulant lorsqu'il apparaît si tu ne veux pas taper le reste et potentiellement faire une faute d'orthographe.

Supports pour une indexation supplémentaire

Un autre opérateur d'indexation à connaître est celui des "crochets" qui ressemblent à [ ]. Ils permettent d'extraire une sous-partie d'un objet plus grand en utilisant le modèle suivant :

object[ROW, COLUMN]

Par exemple, tests[10, 4] renvoie la valeur de tests à la 10e ligne et à la 4e colonne.

Tu peux retourner une colonne entière en utilisant des parenthèses en laissant la partie ROWS vide (mais n'oublie pas la virgule !): tests[ , 4] ou tu peux retourner une ligne entière en faisant l'inverse : tests[10, ]

D'autres objets peuvent également être sous-ensembles. Par exemple, l'objet summary() lorsqu'elle est utilisée sur un colonne renvoie un objet qui contient le minimum, la médiane, la moyenne, l'IQR, etc.

Essaie les 3 commandes ci-dessous pour voir comment le résultat change au fur et à mesure que l'indexation est appliquée :

# Return the summary of the column 'age'
summary(tests$tests_requested)

# Return the 3rd element of the summary
summary(tests$tests_requested)[3]

# Return the number only, of the 3rd element of the summary
# Double brackets look deeper into nested objects
summary(tests$tests_requested)[[3]]

# Do something with the number
summary(tests$tests_requested)[[3]] + 4

Tu utiliseras la commande $ très souvent. Il est moins courant d'avoir besoin ou d'utiliser les parenthèses, mais c'est tout de même bon à savoir.

Faire un tracé

Ci-dessous, nous te fournissons un code R pour réaliser un tracé des données du test COVID-19.

Tu n'as PAS besoin de taper ce code - il te suffit de le copier et de le coller ! Colle ce code dans ton script, sous les commandes d'importation, et exécute-le.

Plus loin dans ce cours, tu apprendras à comprendre et à écrire ce code, ainsi qu'à créer tes propres tracés !

# create a plot of tests used by site and month
ggplot(data = tests,         # use the tests dataset
       mapping = aes(        # map axes to columns in the dataset
         x = month,          # set x-axis to month column
         y = tests_used,     # set y-axis to tests_used column
         color = site))+     # set line color by site
geom_line()+                 # display the data as lines
theme_light()+               # simple background
labs(title = "COVID-19 tests used, by month") # add a title

Vois-tu la sortie apparaître dans le volet RStudio Plots en bas à droite ? Tu peux ajuster la taille du volet, selon tes besoins.

Comme c'est amusant ! Avec seulement quelques lignes de code, nous avons créé un magnifique graphique ! R est un outil extrêmement polyvalent. Tu peux l'enregistrer au format PNG, l'intégrer à une diapositive Powerpoint (PPT) ou l'intégrer à un rapport de routine qui se met à jour automatiquement lorsque de nouvelles données sont communiquées.

Créer un tableau récapitulatif

Il existe de nombreuses façons de réaliser des tableaux récapitulatifs dans R, que nous explorerons dans un module ultérieur. Voici quelques exemples.

Copie et colle le code suivant dans ton script et exécute-le - Ne t'inquiète pas si tu ne le comprends pas. Tu finiras par comprendre !

Ce code utilise le {gtsummary} et sa fonction tbl_summary pour produire un tableau HTML qui peut être incorporé avec R dans un rapport Word, PDF ou HTML, ou dans un site Web/ tableau de bord.

# make an HTML summary table, by site
tests %>%                                                   # start with tests data
  select(site, tests_requested, tests_used, staffing) %>%   # select our columns
  tbl_summary(by = site) %>%                                # summary table by site
  modify_caption("Assessment of testing site needs")        # Add title

Crée un tableau avec des statistiques descriptives détaillées

Dans cet exemple, nous utilisons la fonction {tidyverse} pour effectuer des calculs descriptifs plus complexes dans un tableau récapitulatif.

Copie et colle le code R ci-dessous au bas de ton script, puis clique sur ton curseur dans la ligne supérieure de la commande et appuie sur "Exécuter" pour lancer toute la commande.

Plus tard dans le cours, tu pourras comprendre ce que fait ce code. Il commence par agréger les lignes par site de test, en créant de nouvelles colonnes de résumé avec des moyennes, des maximums et des pourcentages par site. Les lignes suivantes adaptent le tableau dans un joli format avec un en-tête, une légende et même une mise en évidence qui réagit automatiquement aux valeurs !

# make a summary table of testing site performance
tests %>% 
  # group the data by site   
  group_by(site) %>% 

  # calculate summary statistics
  summarise(
    avg_tests = round(mean(tests_used, na.rm = T), digits = 1),
    max_tests = max(tests_used, na.rm=T),
    peak_month = month(which.max(tests_used), label=T),
    pct_understaffed = percent(sum(staffing == "understaffed", na.rm=T)/12))%>%

  # make the table look pretty (formatting)
  qflextable() %>% 
  set_header_labels(
    site = "Site",
    avg_tests = "Average\ntests",
    max_tests = "Max\ntests",
    peak_month = "Peak\nmonth",
    pct_understaffed = "% of months\n understaffed"
  ) %>% 
  bg(i = ~pct_understaffed >= 50, j = 5, part = "body", bg = "#FF7F7F") %>% 
  add_footer_lines("Sites understaffed >= 50% of months are highlighted.") %>% 
  italic(part = "footer") %>% 
  add_header_lines(values = "COVID-19 Testing Site Performance (annual summary)") %>% 
  align(part = "header", i = 1, align = "center") %>% 
  bold(i = 1, bold = TRUE, part = "header")

Tu peux imprimer ce tableau au format PNG, l'envoyer dans un document Word ou PDF, ou l'intégrer dans un jeu de diapositives ou un rapport en ligne.

Il est important de noter , pour mettre à jour le tableau, il te suffit de réexécuter ton script en utilisant un ensemble de données mis à jour Cela signifie que si le fichier testing_data.csv est mis à jour avec de nouvelles données et que tu réexécutes ton script tel qu'il a été écrit, le tableau sera mis à jour en fonction des nouvelles données, sans que tu aies à modifier le script. C'est incroyable !

Ferme et rouvre RStudio

N'hésite pas à fermer RStudio à la fin de ta session R. Essayons-le maintenant ! Effectue les étapes suivantes :

1) Sauvegarde ton script Tu peux le faire en allant dans le menu Fichier et en cliquant sur "Enregistrer" ou en cliquant sur l'icône d'enregistrement qui ressemble à une "disquette".

2) Ferme RStudio (par exemple, clique sur le x dans le coin supérieur droit pour quitter).

Maintenant, entraîne-toi à rouvrir RStudio *sur ce projet "module1*. Tu te souviens comment ?

quiz(caption = "Quiz - Reopen RStudio",

     question("Which ways below will work to open RStudio and resume your work in a specific RStudio project?",
              allow_retry = T,
              answer("Just open RStudio from its desktop icon - it will automatically open to my project",
                     correct = FALSE,
                     message = "Not necessarily! Opening RStudio generically will automatically open the most recent project"),
              answer("Navigate to the folder of the desired project, and then open its RStudio project file",
                     correct = TRUE,
                     message = "Yes, you can click on the RStudio project file for the project you wish to open. "),
              answer("Open RStudio generally, then navigate using the top-right menu to the project I want to work on",
                     correct = TRUE,
                     message = "Yes, you can navigate to a project from within RStudio.")
  )

)

Maintenant que RStudio est à nouveau ouvert à ton projet, que remarques-tu ? Si tu as suivi les instructions au début de ce module sur les paramètres de l'espace de travail et la gestion des ".RData", tu devrais voir que :

• Ton environnement est vide
• Ta console est vide
• Ton script doit être ouvert, ou accessible via le volet Fichiers en bas à droite.

Ouvre ton script R et exécute les commandes une par une, en commençant par le début du script Observe la recréation des objets, l'impression des sorties, la réimportation des données. Si tu rencontres des erreurs, pense à réorganiser les commandes dans le script. Si tu n'y comprends rien, consulte un instructeur.

Remarque : tu dois toujours exécuter ton pacman::p_load() pour t'assurer que tu as chargé tous les paquets nécessaires et les fonctions associées et que tu es prêt à les utiliser pour la session en cours.

Remarque, nous avons stocké un script "solution" dans le dossier "intro_course/module1/backup". C'est un exemple de ce à quoi ton script pourrait ressembler à la fin du module.

Fin

Félicitations pour avoir terminé le premier module !

Clique sur la section suivante si tu veux du matériel supplémentaire...

Suppléments

Si tu finis plus tôt, voici quelques tâches pour un apprentissage supplémentaire :

Guide de style R

Voir ce qui suit Guide de style Tidyverse pour des conseils sur la façon de s'aligner sur les meilleures pratiques de codage R.

Installer des paquets amusants

Si la plupart des paquets R effectuent des analyses spécifiques ou rendent les flux de travail plus efficaces, les programmeurs R sont aussi des gens amusants qui ont créé des paquets pour s'amuser.

{praise}

Essaie d'installer le paquet R {praise} et vois ensuite ce que la fonction praise() à partir de la page {praise} paquet.

pacman::p_load(praise)

praise()

C'est un paquet amusant à utiliser si tu construis un tutoriel !

{cowsay}

Essaie maintenant d'installer le paquetage R {cowsay} - un paquet qui permet d'imprimer des images ridicules d'animaux fabriquées à partir de symboles de ponctuation.

pacman::p_load(cowsay)

La fonction say() a un argument obligatoire what = auquel tu peux fournir une valeur de caractère qui sera prononcée par un chat :

say(what = "Hi, I am a cat who is learning R!")

Le deuxième argument est by = et il peut accepter le nom d'un autre animal comme "poulet", "yoda", "araignée", "fourmi" ou "grenouille".

say(what = "Even frogs like to learn R!", by = "frog")

Tu peux changer les couleurs avec la commande by_color = et what_color = arguments. Pour en savoir plus, consulte la documentation du paquet en entrant ?say dans ta console R.

Amuse-toi bien avec ça !

{aRtsy}

La fonctionnalité de visualisation des données de R est d'une telle qualité que les utilisateurs ont écrit un paquet pour générer de l'art.

Installe le paquet {aRtsy} et charge-le pour l'utiliser.

pacman::p_load(aRtsy)

Certaines illustrations peuvent prendre beaucoup de temps à générer (voir la [documentation du paquet (https://koenderks.github.io/aRtsy/)]), mais essaie celle-ci:

canvas_collatz(colors = colorPalette("tuscany3"))

Comme décrit dans la documentation du paquet :

La conjecture de Collatz est également connue sous le nom d'équation 3x+1. L'algorithme trace des lignes selon un ensemble de règles simples :

1. Prends un nombre positif au hasard.
2. Si le nombre est pair, divise-le par 2.
3. Si le nombre est impair, multiplie-le par 3 et ajoute 1.
4. Répète l'opération pour obtenir une suite de nombres. En visualisant la séquence pour chaque nombre, en superposant des séquences identiques et en pliant les bords différemment pour les nombres pairs et impairs de la séquence, on peut obtenir des structures d'apparence organique.

Personnaliser RStudio

Lis les informations sur ce lien et règle les paramètres de ton RStudio via le menu "Outils" et en cliquant sur "Options globales". Quels sont les paramètres d'apparence que tu préfères ?

Communautés d'utilisateurs R

Regarde à travers cette liste des communautés d'utilisateurs de R et trouve-en une près de chez toi. Voir aussi cette liste de Femmes R . R-Ladies est l'un des plus grands groupes d'utilisateurs de R au monde ! Maintenant que tu as un compte Applied Epi, n'oublie pas d'aller jeter un coup d'œil à la page d'accueil de R-Ladies. forum de la communauté d'Applied Epi également. Le forum de la communauté Applied Epi est un espace où l'on peut poser des questions sur le code R, se renseigner sur les paquets R ou les fonctions qui nous intéressent, et discuter de tout ce qui concerne R avec les anciens élèves, les étudiants actuels et les membres de l'équipe Applied Epi !

Mardi bien rangé

Un phénomène social R très populaire est le "Tidy Tuesday" - le jour de la semaine où de nombreux utilisateurs R effectuent une tâche amusante de visualisation de données en R et la partagent avec la communauté. C'est une façon amusante de s'entraîner et d'apprendre de nouvelles astuces R.

Jette un coup d'œil au hash "TidyTuesday" sur Twitter (ou suis @TidyTuesday_Bot) et passe en revue les superbes tracés que les gens réalisent avec R !

Origine de R

Si tu es intéressé, regarde cette vidéo de 7 minutes interview vidéo de avec l'un des cofondateurs de R, Ross Ihaka, produite par Maori TV en Nouvelle-Zélande, son pays d'origine. Il parle de la philosophie qui l'a poussé à créer R, des influences maories sur sa vie, et bien plus encore.

Révise les bases

Lis le chapitre "Les bases de R" du manuel de l'utilisateur. Manuel Epi R - il est rempli de choses que tu as apprises aujourd'hui, mais aussi de sujets qui seront nouveaux.

Si une section te semble confuse, demande des éclaircissements à ton instructeur.

Créer des fonctions

La magie de R se produit vraiment lorsque tu créer tes propres fonctions. Il s'agit d'une compétence avancée que nous n'abordons pas dans ce cours, et tu n'as généralement pas besoin de créer des fonctions avant d'être un utilisateur R plus expérimenté. Tu n'as pas besoin d'essayer ce code, à moins que tu ne le veuilles. Il s'agit uniquement d'informations générales.

Cependant, c'est dans cet aspect de R que sa polyvalence commence vraiment à briller. Imagine que tu puisses convertir tout ton flux de travail en une seule commande ?

À des fins de démonstration, ci-dessous, le script de la chaîne d'approvisionnement des tests de la section précédente est converti en une fonction :

# create a function that accepts 4 inputs (1 is optional) and returns the 
# needs, based on the equation  

# create the function calc_test()
calc_tests <- function(site1, site2, site3, extra){   # list the arguments, and open the function

     needs <- ((site1 + site2 + site3)*1.1) - extra   # We embed the equation inside the function
     return(needs)                                    # the function returns the result
}                                                     # close the function

Une fois le code ci-dessus exécuté, la fonction est définie (elle apparaîtra dans le volet environnement de R comme les autres objets).

Maintenant que la fonction calc_tests a été définie et créée, nous pouvons l'utiliser pour exécuter l'équation en donnant des valeurs aux arguments, comme ceci :

calc_tests(site1 = 200, site2 = 550, site3 = (925*2), extra = 420)

Ou avec des valeurs différentes pour les arguments de la fonction :

calc_tests(site1 = 400, site2 = 150, site3 = (700*2), extra = 85)

Regarde comment nous avons regroupé tout le code dans une fonction ! C'est très cool. Pense aux possibilités... tu peux créer des fonctions qui répondent à tes besoins locaux !

Si tu écris une fonction qui est utile à d'autres, tu peux la publier dans un paquetage R - une unité de plusieurs fonctions apparentées. Tout le monde peut tester et essayer tes fonctions, et ton travail peut aider les gens du monde entier ! C'est la beauté des logiciels libres.

Réviser le chapitre sur l'importation et l'exportation

Ce chapitre du manuel Epi R couvre plus en détail l'importation et l'exportation de données, y compris :

• Comment importer des feuilles de calcul Google
• Comment importer des données à partir d'une API
• Comment saisir des données manuellement
• Comment importer l'ensemble de données le plus récent dans un dossier ?

Nous discuterons de l'utilisation de here() dans le prochain module.

Importer des données volumineuses

Lire à propos de la {vroom} Paquet R qui est conçu pour importer rapidement de très grands ensembles de données. Essaie-le !

appliedepi/introexercises documentation built on April 22, 2024, 1:01 a.m.