forked from MathildeMousset/epiRhandbook_fr
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy path_main.Rmd
3707 lines (2704 loc) · 171 KB
/
_main.Rmd
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
---
knit: "bookdown::render_book"
title: "The Epidemiologist R Handbook"
description: "The Epi R Handbook est un manuel de référence sur l'utilisation de R en épidémiologie appliquée et santé publique."
author: "the handbook team"
date: "`r Sys.Date()`"
#url: 'https://github.com/appliedepi/epiRhandbook_fr'
#twitter-handle:
#cover-image: images/R_Handbook_Logo.png
site: bookdown::bookdown_site
# output: bookdown::gitbook:
# config:
# sharing:
# twitter: yes
# facebook: yes
# whatsapp: yes
# github: yes
documentclass: book
---
# output: bookdown::gitbook:
Placeholder
## R pour l'épidémiologie appliquée et la santé publique {-}
## Comment utiliser ce mannuel ? {-}
## Remmerciements {-}
### Auteurs et contributeurs {-}
### Financements {-}
### Inspirations {-}
## Conditions d'utilisation et contribution {-}
### License {.unnumbered}
### Citation {.unnumbered}
### Contribuer {.unnumbered}
<!--chapter:end:index.Rmd-->
# (PART) About this book {.unnumbered}
```{r include=FALSE, cache=FALSE}
# clear workspace
rm(list = ls(all = TRUE))
# clear all packages except base
#lapply(names(sessionInfo()$loadedOnly), require, character.only = TRUE)
#invisible(lapply(paste0('package:', names(sessionInfo()$otherPkgs)), detach, character.only=TRUE, unload=TRUE, force=TRUE))
# to ensure that tidyverse packages prevail
filter <- dplyr::filter
select <- dplyr::select
summarise <- dplyr::summarise
summary <- base::summary
incidence <- incidence2::incidence
#load core packages
pacman::p_load(
rio,
here,
DT,
stringr,
lubridate,
tidyverse
)
# import the cleaned ebola linelist
linelist <- rio::import(here::here("data", "case_linelists", "linelist_cleaned.rds"))
# import the count data - facility level
#count_data <- rio::import(here::here("data", "facility_count_data.rds"))
# Settings
options(scipen=1, digits=7)
# print only text (not code)
# library(knitr)
# opts_chunk$set(list(echo = FALSE, eval = FALSE))
```
<!--chapter:end:new_pages/cat_about_book.Rmd-->
# Notes techniques et choix éditoriaux {#editorial_notes}
Placeholder
## Approche et style
### Paquets R {.unnumbered}
### Choix d'yn style de code {.unnumbered}
### Nomenclature {.unnumbered}
### Notes {.unnumbered}
## Choix techniques
## Révisions majeures
## Information de session (R, RStudio, paquets)
<!--chapter:end:new_pages/editorial_style.Rmd-->
# Télécharger le manuel et les données {#download_book_data}
Placeholder
## Télécharger le manuel hors-ligne {#download_offline}
### Utiliser le lien de téléchargement {.unnumbered}
### Utiliser notre paquet R {.unnumbered}
## Télécharger les données
### Utiliser notre paquet R {.unnumbered}
### Téléchargement manuel {.unnumbered}
#### Liste de cas (linelist) {.unnumbered}
#### Cas de paludisme {#data_malaria .unnumbered}
#### Données sur l'échelle de Likert {.unnumbered}
#### Flexdashboard {.unnumbered}
#### recherche des contacts {.unnumbered}
#### SIG {.unnumbered}
#### Arbres phylogénétiques {.unnumbered}
#### Standardization {.unnumbered}
#### Séries temporelles et détection des épidémies {#data_outbreak .unnumbered}
#### Analyse d'enquêtes {#data_survey .unnumbered}
#### Shiny {#data_shiny .unnumbered}
<!--chapter:end:new_pages/data_used.Rmd-->
# (PART) Basics {.unnumbered}
```{r include=FALSE, cache=FALSE}
# clear workspace
rm(list = ls(all = TRUE))
# clear all packages except base
#lapply(names(sessionInfo()$loadedOnly), require, character.only = TRUE)
#invisible(lapply(paste0('package:', names(sessionInfo()$otherPkgs)), detach, character.only=TRUE, unload=TRUE, force=TRUE))
# to ensure that tidyverse packages prevail
filter <- dplyr::filter
select <- dplyr::select
summarise <- dplyr::summarise
summary <- base::summary
incidence <- incidence2::incidence
#load core packages
pacman::p_load(
rio,
here,
DT,
stringr,
lubridate,
tidyverse
)
# import the cleaned ebola linelist
linelist <- rio::import(here::here("data", "case_linelists", "linelist_cleaned.rds"))
# import the count data - facility level
#count_data <- rio::import(here::here("data", "facility_count_data.rds"))
# Settings
options(scipen=1, digits=7)
# print only text (not code)
# library(knitr)
# opts_chunk$set(list(echo = FALSE, eval = FALSE))
```
<!--chapter:end:new_pages/cat_basics.Rmd-->
---
title: "EpiR handbook"
subtitle: "R basics chapter"
output: html_document
---
# R - les bases {#rbasics}
```{r out.width = "100%", fig.align = "center", echo=F}
knitr::include_graphics(here::here("images", "basics_header_close.png"))
```
Bienvenue !
Cette page passe en revue les éléments essentiels de R. Elle n'a pas pour but d'être un tutoriel complet, mais elle fournit les bases et peut être utile pour rafraîchir votre mémoire. La section [Ressources pour l'apprentissage](#learning) renvoie à des didacticiels plus complets.
Certaines parties de cette page ont été adaptées avec l'autorisation du [projet R4Epis](https://r4epis.netlify.app/).
Voir la page $$Transition to R$$ pour des conseils sur le passage de STATA, SAS ou Excel à R.
```{r, echo=F}
# Importer la liste linéaire nettoyée d'ebola:
linelist <- rio::import(here::here("data",
"case_linelists",
"linelist_cleaned.rds"))
# Chargez le paquet apyramid (contient tableaux de données d'exemple):
pacman::p_load(apyramid)
```
<!-- ======================================================= -->
## Pourquoi utiliser R ?
Comme indiqué sur le [site Web du projet R](https://www.r-project.org/about.html), R est un langage de programmation et un environnement pour le calcul statistique et les graphiques. Il est très polyvalent, extensible et axé sur la communauté.
**Coût**
L'utilisation de R est gratuite ! Il existe une forte éthique dans la communauté du matériel gratuit et open-source.
**Reproductibilité**
La gestion et l'analyse de vos données par le biais d'un langage de programmation (par rapport à Excel ou à un autre outil essentiellement manuel) améliore la reproductibilité, facilite la détection des erreurs et allège votre charge de travail.
**Communauté**
La communauté des utilisateurs de R est énorme et collaborative. De nouveaux paquets et outils destinés à résoudre des problèmes concrets sont développés quotidiennement et approuvés par la communauté des utilisateurs. À titre d'exemple, [R-Ladies](https://rladies.org/) est une organisation mondiale dont la mission est de promouvoir la diversité des genres dans la communauté R, et c'est l'une des plus grandes organisations d'utilisateurs de R. Elle a probablement un chapitre près de chez vous !
## Termes clés
**RStudio** - RStudio est une interface utilisateur graphique (GUI) qui facilite l'utilisation de **R**. Pour en savoir plus, consultez la section [RStudio](#rstudio).
**Objets** - Tout ce que vous stockez dans R - les jeu de données, les variables, une liste de noms de villages, un population total d'habitants, et même les résultats tels que les graphiques - sont des *objets* auxquels on *attribue un nom* et qui *peuvent être référencés* dans des commandes ultérieures. Pour en savoir plus, consultez la section [Objets](#objects).
**Fonctions** - Une fonction est une opération de code qui accepte des entrées et renvoie une sortie transformée. Pour en savoir plus, consultez la section [Fonctions](#functions).
**Paquets** - Un paquet R est un ensemble de fonctions partageables. Pour en savoir plus, consultez la section [Packages](#packages).
**Scripts** - Un script est le fichier document qui contient vos commandes. Pour en savoir plus, consultez la section [Scripts](#scripts)
## Ressources pour l'apprentissage {#learning}
### Ressources au sein de RStudio {.unnumbered}
**Documentation d'aide**
Recherchez dans l'onglet "Aide" de RStudio la documentation sur les paquets R et les fonctions spécifiques. Cet onglet se trouve dans le volet qui contient également les fichiers, les graphiques et les paquets (généralement dans le volet inférieur à droit). Comme raccourci, vous pouvez également taper le nom d'un paquet ou d'une fonction dans la console R après un point d'interrogation pour ouvrir la page d'aide correspondante. N'incluez pas les parenthèses.
Par exemple : `?filter` ou `?diagrammeR`.
**Tutoriels interactifs**
Il existe plusieurs façons d'apprendre R de manière interactive *dans* RStudio.
RStudio lui-même offre un volet Tutoriel qui est alimenté par le paquet R [**learnr**](https://blog.rstudio.com/2020/02/25/rstudio-1-3-integrated-tutorials/). Il suffit d'installer ce paquet et d'ouvrir un tutoriel via le nouvel onglet "Tutorial" dans le volet supérieur droit de RStudio (qui contient également les onglets Environnement et Historique).
Le paquet R [**swirl**](https://swirlstats.com/) propose des cours interactifs dans la console R. Installez et chargez ce paquet, puis lancez la commande `swirl()` (parenthèses vides) dans la console R. Vous verrez apparaître des invites dans la console. Répondez en tapant dans la console. Elle vous guidera à travers un cours de votre choix.
### Fiches d'aide-mémoire {.unnumbered}
Il existe de nombreuses fiches d'aide-mémoire au format PDF disponibles sur le [site Web de RStudio](https://rstudio.com/resources/cheatsheets/), par exemple :
- Facteurs avec le paquet **forcats**\
- Dates et heures avec le paquet **lubridate**\
- Chaînes de caractères avec le paquet **stringr**\
- Opérations itératives avec le paquet **purrr**\
- Importation de données\
- Aide-mémoire pour la transformation des données avec le paquet **dplyr**\
- R Markdown (pour créer des documents comme PDF, Word, Powerpoint...)\
- Shiny (pour créer des applications Web interactives)\
- Visualisation de données avec le paquet **ggplot2**\
- Cartographie (SIG)\
- Paquet **leaflet** (cartes interactives)\
- Python avec R (paquet **reticulate**)
Il existe également une ressource R en ligne spécialement destinée aux [utilisateurs d'Excel](https://jules32.github.io/r-for-excel-users/).
### Twitter {.unnumbered}
R possède une communauté Twitter dynamique où vous pouvez apprendre des astuces, des raccourcis et des nouvelles - suivez ces comptes :
- Suivez-nous ! [\@epiRhandbook](https://twitter.com/epirhandbook)\
- R Function A Day [\@rfuntionaday](https://twitter.com/rfunctionaday) est une ressource *incroyable*\
- R pour la science des données [\@rstats4ds](https://twitter.com/rstats4ds?lang=en)\
- RStudio [\@RStudio](https://twitter.com/rstudio?lang=en)\
- Conseils sur RStudio [\@rstudiotips](https://twitter.com/rstudiotips)\
- R-Bloggers [\@Rbloggers](https://twitter.com/Rbloggers)\
- R-ladies [\@RLadiesGlobal](https://twitter.com/RLadiesGlobal)\
- Hadley Wickham [\@hadleywickham](https://twitter.com/hadleywickham?ref_src=twsrc%5Egoogle%7Ctwcamp%5Eserp%7Ctwgr%5Eauthor)
Aussi :
**#epitwitter** et **#rstats**
### Ressources gratuites en ligne {.unnumbered}
Un texte définitif est le livre [R for Data Science](https://r4ds.had.co.nz/) de Garrett Grolemund et Hadley Wickham.
Le site Web du projet [R4Epis](https://r4epis.netlify.app/) vise à "développer des outils standardisés de nettoyage, d'analyse et de rapport des données pour couvrir les types courants d'épidémies et d'enquêtes auprès de la population qui seraient menées dans le cadre d'une réponse d'urgence de MSF". Vous y trouverez des supports de formation aux bases de R, des modèles de rapports RMarkdown sur les épidémies et les enquêtes, ainsi que des tutoriels pour vous aider à les configurer.
### Langues autres que l'anglais {.unnumbered}
[Materiales de RStudio en Español](https://www.rstudio.com/collections/espanol/)
[Introduction à R et au tidyverse (Francais)](https://juba.github.io/tidyverse/index.html)
<!-- ======================================================= -->
## Installation
### R et RStudio {.unnumbered}
**Comment installer R**
Visitez ce site Web <https://www.r-project.org/> et téléchargez la dernière version de R adaptée à votre ordinateur.
**Comment installer RStudio**
Visitez ce site Web <https://rstudio.com/products/rstudio/download/> et téléchargez la dernière version de bureau gratuite de RStudio adaptée à votre ordinateur.
**Autorisations requises**\
Notez que vous devez installer R et RStudio sur un lecteur sur lequel vous avez des droits de lecture et d'écriture. Sinon, votre capacité à installer des paquets R (ce qui arrive fréquemment) sera affectée. Si vous rencontrez des problèmes, essayez d'ouvrir RStudio en faisant un clic droit sur l'icône et en sélectionnant "Exécuter en tant qu'administrateur". Vous trouverez d'autres conseils sur la page $$R sur les lecteurs réseau$$.
**Comment mettre à jour R et RStudio**
Votre version de R est imprimée dans la Console R au démarrage. Vous pouvez également exécuter `sessionInfo()`.
Pour mettre à jour R, allez sur le site web mentionné ci-dessus et réinstallez R. Alternativement, vous pouvez utiliser le paquet **installr** (sous Windows) en exécutant `installr::updateR()`. Cela ouvrira des boîtes de dialogue pour vous aider à télécharger la dernière version de R et à mettre à jour vos paquets vers la nouvelle version de R. Plus de détails peuvent être trouvés dans la [documentation de **installr**](https://www.r-project.org/nosvn/pandoc/installr.html).
Sachez que l'ancienne version de R existera toujours sur votre ordinateur. Vous pouvez temporairement exécuter une ancienne version (ancienne "installation") de R en cliquant sur "Outils" -\> "Options globales" dans RStudio et en choisissant une version de R. Cela peut être utile si vous voulez utiliser un paquet qui n'a pas été mis à jour pour fonctionner sur la version la plus récente de R.
Pour mettre à jour RStudio, vous pouvez aller sur le site Web ci-dessus et retélécharger RStudio. Une autre option consiste à cliquer sur "Aide" -\> "Vérifier les mises à jour" dans RStudio, mais cela peut ne pas montrer les toutes dernières mises à jour.
Pour savoir quelles versions de R, RStudio ou des paquets ont été utilisées lors de la réalisation de ce manuel, consultez la page sur $$Notes éditoriales et techniques$$.
### Autres logiciels que vous *pourriez* avoir besoin d'installer {.unnumbered}
- TinyTeX (*pour la compilation d'un document RMarkdown au format PDF*)\
- Pandoc (*pour compiler des documents RMarkdown*)\
- RTools (*pour construire des paquets pour R*)\
- phantomjs (*pour enregistrer des images fixes de réseaux animés, tels que des chaînes de transmission*)
#### TinyTex {.unnumbered}
TinyTex est une distribution LaTeX personnalisée, utile lorsqu'on essaie de produire des PDF à partir de R.\
Voir <https://yihui.org/tinytex/> pour plus d'informations.
Pour installer TinyTex à partir de R :
```{r, eval=F}
install.packages('tinytex')
tinytex::install_tinytex()
# pour désinstaller TinyTeX, lancez tinytex::uninstall_tinytex()
```
#### Pandoc {.unnumbered}
Pandoc est un convertisseur de document, un logiciel séparé de R. **Il est fourni avec RStudio et ne devrait pas avoir besoin d'être téléchargé.** Il aide le processus de conversion de documents Rmarkdown à des formats comme .pdf et ajoute des fonctionnalités complexes.
#### RTools {.unnumbered}
RTools est une collection de logiciels permettant de construire des paquets pour R.
Installer à partir de ce site web : <https://cran.r-project.org/bin/windows/Rtools/>
#### phantomjs {.unnumbered}
Cet outil est souvent utilisé pour faire des "captures d'écran" des pages web. Par exemple, lorsque vous faites une chaîne de transmission avec le paquet **epicontacts**, un fichier HTML interactif et dynamique est produit. Si vous voulez une image statique, il peut être utile d'utiliser le paquet [**webshot**](https://wch.github.io/webshot/articles/intro.html) pour automatiser ce processus. Cela nécessite le programme externe "phantomjs". Vous pouvez installer phantomjs via le paquet **webshot** avec la commande `webshot::install_phantomjs()`.
<!-- ======================================================= -->
### RStudio {#rstudio}
### Orientation de RStudio {.unnumbered}
**D'abord, ouvrez RStudio.** Comme leurs icônes peuvent être très similaires, assurez-vous que vous ouvrez bien *RStudio* et non pas R.
Pour que RStudio fonctionne, vous devez également avoir R installé sur l'ordinateur (voir ci-dessus pour les instructions d'installation).
**RStudio** est une interface (GUI) pour une utilisation plus facile de **R**. Vous pouvez considérer R comme le moteur d'un véhicule, qui effectue le travail crucial, et RStudio comme le corps du véhicule (avec les sièges, les accessoires, etc.) qui vous aide à utiliser le moteur pour avancer ! Vous pouvez consulter la fiche technique complète de l'interface utilisateur de RStudio (PDF) [ici](https://www.rstudio.com/wp-content/uploads/2016/01/rstudio-IDE-cheatsheet.pdf)
Par défaut, RStudio affiche quatre volets rectangulaires.
```{r out.width = "100%", fig.align = "center", echo=F}
knitr::include_graphics(here::here("images", "RStudio_overview.png"))
```
[***TIP:*** Si votre RStudio n'affiche qu'un seul volet gauche, c'est parce que vous n'avez pas encore de scripts ouverts.]{style="color: black;"}
**Le volet source**
Ce volet, par défaut en haut à gauche, est un espace pour éditer, exécuter et enregistrer vos [scripts](#scripts). Les scripts contiennent les commandes que vous souhaitez exécuter. Ce volet peut également afficher des ensembles de données (cadres de données) pour les visualiser.
Pour les utilisateurs de Stata, ce volet est similaire aux fenêtres Do-file et Data Editor.
**Le volet Console R**
La console R, qui est par défaut le volet gauche ou inférieur gauche de R Studio, est le siège du "moteur" R. C'est là que les commandes sont réellement exécutées et que les sorties non graphiques et les messages d'erreur/d'avertissement apparaissent. Vous pouvez saisir et exécuter directement des commandes dans la console R, mais sachez que ces commandes ne sont pas enregistrées comme c'est le cas lorsque vous exécutez des commandes à partir d'un script.
Si vous êtes familier avec Stata, la console R ressemble à la fenêtre de commande et à la fenêtre des résultats.
**Le volet Environnement**
Ce volet, situé par défaut en haut à droite, est le plus souvent utilisé pour afficher de brefs résumés des [objets](#objets) de l'environnement R dans la session en cours. Ces objets peuvent inclure des ensembles de données importés, modifiés ou créés, des paramètres que vous avez définis (par exemple, une semaine épi spécifique pour l'analyse), ou des vecteurs ou des listes que vous avez définis pendant l'analyse (par exemple, les noms des régions). Vous pouvez cliquer sur la flèche à côté du nom d'un cadre de données pour voir ses variables.
Dans Stata, cette fenêtre est très similaire à celle du gestionnaire de variables.
Ce volet contient également l'onglet "Historique" où vous pouvez voir les commandes que vous avez exécutées précédemment. Il comporte également un onglet "Tutoriel" où vous pouvez suivre des tutoriels R interactifs si vous avez installé le paquet **learnr**. En outre, il existe un volet "Connexions" pour les connexions aux bases de données externes. Si vous avez lié le répertoire actif à un dépôt sur Github, il y aura également un volet "Git".
**Volets Graphiques, visionneuse, paquets et aide**
Le volet inférieur droit comprend plusieurs onglets importants. Les graphiques de tracé typiques, y compris les cartes, s'affichent dans le volet Tracé. Les sorties interactives ou HTML s'affichent dans le volet Visionneuse. Le volet Aide permet d'afficher la documentation et les fichiers d'aide. Le volet Fichiers est un navigateur qui peut être utilisé pour ouvrir ou supprimer des fichiers. Le volet Paquets vous permet de voir, d'installer, de mettre à jour, de supprimer, de charger/décharger des paquets R et de voir quelle version du paquet vous avez. Pour en savoir plus sur les paquets, consultez la [section paquets](#packages) ci-dessous.
Ce volet contient les équivalents Stata des fenêtres Plots Manager et Project Manager.
### Paramètres RStudio {.unnumbered}
Modifiez les paramètres et l'apparence de RStudio dans le menu déroulant *Outiles*, en sélectionnant *Options globales*. Vous pouvez y modifier les paramètres par défaut, y compris l'apparence/couleur de fond.
```{r out.width = c('50%'), fig.show='hold', echo=F}
knitr::include_graphics(here::here("images", "RStudio_tools_options_1.png"))
knitr::include_graphics(here::here("images", "RStudio_tools_options.png"))
```
**Redémarrage**
Si votre R se fige, vous pouvez redémarrer R en allant dans le menu Session et en cliquant sur "Redémarrer R". Cela vous évite de devoir fermer et ouvrir RStudio. Tout ce qui se trouve dans votre environnement R sera supprimé lorsque vous ferez cela.
### Raccourcis clavier {.unnumbered}
Vous trouverez ci-dessous quelques raccourcis clavier très utiles. Vous trouverez tous les raccourcis clavier pour Windows, Max et Linux sur la deuxième page de ce [fichier technique](https://www.rstudio.com/wp-content/uploads/2016/01/rstudio-IDE-cheatsheet.pdf) par RStudio.
+-----------------------------------------+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Windows/Linux | Mac | Action |
+=========================================+========================+=====================================================================================================================================================================+
| Esc | Esc | Interrompre la commande en cours (utile si vous avez accidentellement lancé une commande incomplète et que vous ne pouvez pas éviter de voir "+" dans la console R) |
+-----------------------------------------+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Ctrl+s | Cmd+s | Sauvegarder (script) |
+-----------------------------------------+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Tab | Tab | Autocomplétion |
+-----------------------------------------+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Ctrl + Enter | Cmd + Enter | Exécuter la ou les ligne(s) courante(s)/sélection(s) de code |
+-----------------------------------------+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Ctrl + Shift + C | Cmd + Shift + c | commenter/dé-commenter les lignes souslignées |
+-----------------------------------------+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Alt + - | Option + - | Insérer `<-` |
+-----------------------------------------+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Ctrl + Shift + m | Cmd + Shift + m | Insérer `%>%` |
+-----------------------------------------+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Ctrl + l | Cmd + l | Effacer le contenu de la console R |
+-----------------------------------------+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Ctrl + Alt + b | Cmd + Option + b | Exécuter du début à la ligne courante |
+-----------------------------------------+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Ctrl + Alt + t | Cmd + Option + t | Exécuter la section de code actuelle (R Markdown) |
+-----------------------------------------+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Ctrl + Alt + i | Cmd + Shift + r | Insérer un morceau de code (en R Markdown) |
+-----------------------------------------+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Ctrl + Alt + c | Cmd + Option + c | Exécuter le morceau de code actuel (en R Markdown) |
+-----------------------------------------+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Flèches haut/bas dans la console R | Idem | Basculer entre les commandes récemment exécutées |
+-----------------------------------------+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Shift + flèches haut/bas dans le script | Idem | Sélectionner plusieurs lignes de code |
+-----------------------------------------+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Ctrl + f | Cmd + f | Rechercher et remplacer dans le script actuel |
+-----------------------------------------+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Ctrl + Shift + f | Cmd + Shift + f | Rechercher dans les dossiers (rechercher/remplacer dans plusieurs scripts) |
+-----------------------------------------+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Alt + l | Cmd + Option + l | Plier le code sélectionné |
+-----------------------------------------+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Shift + Alt + l | Cmd + Shift + Option+l | Déplier le code sélectionné |
+-----------------------------------------+------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+
[***TIP:*** Utilisez votre touche de tabulation lorsque vous tapez pour activer la fonctionnalité de complétion automatique de RStudio. Cela peut éviter les fautes d'orthographe. Appuyez sur la touche Tab pendant la saisie pour produire un menu déroulant de fonctions et d'objets probables, en fonction de ce que vous avez tapé jusqu'à présent.]{style="color: darkgreen;"}
<!-- ======================================================= -->
## Fonctions {#functions}
Les fonctions sont au cœur de l'utilisation de R. Les fonctions vous permettent d'effectuer des tâches et des opérations. De nombreuses fonctions sont installées avec R, beaucoup d'autres sont disponibles à télécharger dans des *paquets* (expliqués dans la section [paquets](#packages)), et vous pouvez même écrire vos propres fonctions personnalisées !
Cette section de base sur les fonctions explique :
- Ce qu'est une fonction et comment elle fonctionne\
- Ce que sont les *paramètres* des fonctions\
- Comment obtenir de l'aide pour comprendre une fonction
*Une note rapide sur la syntaxe :* Dans ce manuel, les fonctions sont écrites en code-texte avec des parenthèses vides, comme ceci : `filter()`. Comme expliqué dans la section [paquets](#packages), les fonctions sont téléchargées dans des *paquets*. Dans ce manuel, les noms de paquets sont écrits en **gras**, comme **dplyr**. Parfois, dans le code d'exemple, vous pouvez voir le nom de la fonction lié explicitement au nom de son paquet avec deux points de suspension (`::`) comme ceci : `dplyr::filter()`. Le but de ce lien est expliqué dans la section sur les paquets.
<!-- ======================================================= -->
### Fonctions simples {.unnumbered}
**Une fonction est comme une machine qui reçoit des entrées, effectue une action avec ces entrées, et produit une sortie.** La nature de la sortie dépend de la fonction.
**Les fonctions opèrent généralement sur un objet placé entre les parenthèses de la fonction**. Par exemple, la fonction `sqrt()` calcule la racine carrée d'un nombre :
```{r basics_function_sqrt}
sqrt(49)
```
L'objet fourni à une fonction peut également être une colonne dans un jeu de données (voir la section [Objets](#objects) pour plus de détails sur tous les types d'objets). Comme R peut stocker plusieurs jeux de données, vous devrez spécifier à la fois le jeu de données et la colonne. Une façon de le faire est d'utiliser la notation `$` pour lier le nom du jeu de données et le nom de la colonne (`dataset$column`). Dans l'exemple ci-dessous, la fonction `summary()` est appliquée à la colonne numérique `age` du jeu de données `linelist`, et la sortie est un résumé des valeurs numériques et manquantes de la colonne.
```{r basics_functions_summary}
# Imprimez les statistiques sommaires de la colonne 'age' dans le jeu de données 'linelist'.
summary(linelist$age)
```
[***NOTE:*** En coulisses, une fonction représente un code supplémentaire complexe qui a été regroupé pour l'utilisateur dans une seule commande simple.]{style="color: black;"}
<!-- ======================================================= -->
### Fonctions à paramètres multiples {.unnumbered}
Les fonctions demandent souvent plusieurs entrées, appelées ***paramètres***, situées entre les parenthèses de la fonction, généralement séparées par des virgules.
- Certains paramètres sont obligatoires pour que la fonction fonctionne correctement, d'autres sont facultatifs\
- Les paramètres facultatifs ont des valeurs par défaut\
- Les paramètres peuvent prendre des entrées de type caractère, numérique, logique (VRAI/FAUX) et autres.
Voici une fonction fictive amusante, appelée `oven_bake()` (cuisson au four), comme exemple d'une fonction typique. Elle prend un objet comme entrée (par exemple un jeu de données, ou dans cet exemple "pâte") et effectue des opérations sur celui-ci comme spécifié par des paramètres supplémentaires (`minutes =` et `température =`). La sortie peut être imprimée sur la console, ou sauvegardée comme un objet en utilisant l'opérateur d'affectation `<-`.
```{r basics_functions_image, echo=F, out.width = "75%", fig.align = "center"}
knitr::include_graphics(here::here("images", "Function_Bread_Example.png"))
```
**Dans un exemple plus réaliste**, la commande `age_pyramid()` ci-dessous produit un graphique de pyramide des âges basé sur des groupes d'âge définis et une colonne de division binaire, comme le genre `gender`. La fonction reçoit trois paramètres entre parenthèses, séparés par des virgules. Les valeurs fournies aux paramètres établissent `linelist` comme le cadre de données à utiliser, `age_cat5` comme la colonne à compter, et `gender` comme la colonne binaire à utiliser pour diviser la pyramide par couleur.
```{r basics_functions_arguments, include=FALSE, results='hide', message=FALSE, warning=FALSE,}
## Créer une variable de groupe d'âge en spécifiant des ruptures catégorielles
linelist$age_group <- cut(linelist$age, breaks = c(0, 5, 10, 15, 20, 30, 45, 60))
```
```{r message=FALSE, warning=FALSE, out.width = "75%", out.height="75%"}
# Créer une pyramide des âges
age_pyramid(data = linelist, age_group = "age_cat5", split_by = "gender")
```
La commande ci-dessus peut être écrite de manière équivalente comme ci-dessous, dans un style plus long avec une nouvelle ligne pour chaque argument. Ce style peut être plus facile à lire, et plus facile d'écrire des "commentaires" avec `#` pour expliquer chaque partie (commenter abondamment est une bonne pratique !). Pour exécuter cette commande plus longue, vous pouvez souligner la commande entière et cliquer sur "Run", ou simplement placer votre curseur sur la première ligne et appuyer simultanément sur les touches `Ctrl` et `Enter`.
```{r message=FALSE, warning=FALSE, out.width = "75%", out.height="75%"}
# Créer une pyramide des âges
age_pyramid(
data = linelist, # utiliser la liste linéaire des cas
age_group = "age_cat5", # fournir une colonne de groupe d'âge
split_by = "gender" # utiliser la colonne genre pour les deux côtés de la pyramide
)
```
La première moitié d'une affectation de paramètre (par exemple `data =`) n'a pas besoin d'être spécifiée si les paramètres sont écrits dans un ordre spécifique (spécifié dans la documentation de la fonction). Le code ci-dessous produit exactement la même pyramide que ci-dessus, parce que la fonction attend l'ordre des paramètres : cadre de données, le variable `age_group`, puis le variable `split_by`.
```{r, basics_functions_pyramid2, eval = FALSE, warning=FALSE, message=FALSE, , out.width = "75%", out.height="75%", eval=F}
# Cette commande produira exactement le même graphique que ci-dessus
age_pyramid(linelist, "age_cat5", "gender")
```
**Une commande `age_pyramid()` plus complexe pourrait inclure les paramètres *optionnels* pour :**
- Afficher les proportions au lieu des nombres (définissez `proportional = TRUE` (vrai) quand la valeur par défaut est `FALSE` (faux))\`\
- Spécifier les deux couleurs à utiliser (`pal =` est l'abréviation de "palette" et est fourni avec un vecteur de deux noms de couleurs. Voir la page [objets](#objectstructure) pour savoir comment la fonction `c()` fabrique un vecteur).
[***NOTE:*** Pour les paramètres que vous spécifiez avec les deux parties du paramètre (par exemple `proportional = TRUE`), leur ordre parmi tous les paramètres n'a pas d'importance.]{style="color: black;"}
```{r message=FALSE, warning=FALSE, out.width = "75%", out.height="75%"}
age_pyramid(
linelist, # utiliser la liste linéaire des cas
"age_cat5", # colonne de groupe d'âge
"gender", # répartition par genre
proportional = TRUE, # pourcentage au lieu du nombre
pal = c("orange", "purple") # couleurs
)
```
<!-- ======================================================= -->
### Ecrire des fonctions {.unnumbered}
R est un langage orienté autour des fonctions, vous devez donc vous sentir capable d'écrire vos propres fonctions. La création de fonctions présente plusieurs avantages :
- Faciliter la programmation modulaire - la séparation du code en morceaux indépendants et gérables\
- Remplacer le copier-coller répétitif, qui peut être source d'erreurs\
- Donner des noms mémorisables aux morceaux de code
L'écriture d'une fonction est traitée en détail à la page [Écriture de fonctions].
<!-- ======================================================= -->
## Paquets {#packages}
**Les paquets contiennent des fonctions.**
Un paquet en R est un ensemble partageable de code et de documentation qui contient des fonctions prédéfinies. Les utilisateurs de la communauté R développent en permanence des packages répondant à des problèmes spécifiques; donc il est probable que l'un d'entre eux puisse vous aider dans votre travail ! Vous allez installer et utiliser des centaines de paquets dans votre utilisation de R.
À l'installation, R contient des paquets et des fonctions **"de base "** qui effectuent des tâches élémentaires communes. Mais de nombreux utilisateurs de R créent des fonctions spécialisées, qui sont vérifiées par la communauté R et que vous pouvez télécharger en tant que **paquet** pour votre propre usage. Dans ce manuel, les noms des paquets sont écrits en **gras**. L'un des aspects les plus difficiles de R est qu'il existe souvent de nombreuses fonctions ou paquets parmi lesquels on peut choisir pour effectuer une tâche donnée.
### Installer et charger {.unnumbered}
Les *fonctions* sont contenues dans des **paquets** qui peuvent être téléchargés ("installés") sur votre ordinateur à partir d'Internet. Une fois qu'un paquet est téléchargé, il est stocké dans votre "bibliothèque". Vous pouvez alors accéder aux fonctions qu'il contient pendant votre séance R actuelle en "chargeant" le paquet.
*Pensez à R comme votre bibliothèque personnelle* : Lorsque vous téléchargez un paquet, votre bibliothèque gagne un nouveau livre de fonctions, mais chaque fois que vous voulez utiliser une fonction de ce livre, vous devez emprunter ("charger") ce livre dans votre bibliothèque.
En résumé : pour utiliser les fonctions disponibles dans un paquet R, deux étapes doivent être mises en œuvre :
1) Le paquet doit être **installé** (une fois), *et*\
2) Le paquet doit être **chargé** (à chaque séance R)
#### Votre bibliothèque {.unnumbered}
Votre "bibliothèque" est en fait un dossier sur votre ordinateur, contenant un dossier pour chaque paquet qui a été installé. Déterminez où R est installé sur votre ordinateur, et cherchez un dossier appelé "win-library". Par exemple : `R\win-library\4.0` (4.0 est la version de R). Notez que vous aurez une bibliothèque différente pour chaque version de R que vous avez téléchargée.
Vous pouvez imprimer le chemin d'accès à votre bibliothèque en entrant `.libPaths()` (parenthèses vides). Ceci devient particulièrement important si vous travaillez avec $$R sur des lecteurs réseau$$.
#### Installer à partir du CRAN {.unnumbered}
Le plus souvent, les utilisateurs de R téléchargent des paquets depuis CRAN. CRAN (Comprehensive R Archive Network) est un entrepôt public en ligne de paquets R qui ont été publiés par des membres de la communauté R.
Vous vous inquiétez des virus et de la sécurité lorsque vous téléchargez un paquet depuis CRAN ? Lisez [cet article](https://support.rstudio.com/hc/en-us/articles/360042593974-R-and-R-Package-Security) à ce sujet.
#### Comment installer et charger {.unnumbered}
Dans ce manuel, nous suggérons d'utiliser le paquet **pacman** (abréviation de "package manager" en anglais). Il offre une fonction pratique `p_load()` qui installera un paquet si nécessaire *et* le chargera pour l'utiliser dans la séance R actuelle.
La syntaxe est assez simple. Il suffit de lister les noms des paquets entre les parenthèses de `p_load()`, séparés par des virgules.
La commande ci-dessous installera les paquets **rio**, **tidyverse**, et **here** s'ils ne sont pas encore installés, et les chargera pour les utiliser. Cela rend l'approche `p_load()` pratique et concise si vous partagez des scripts avec d'autres personnes. Notez que les noms des paquets sont sensibles à la casse.
```{r}
# Installer (si nécessaire) et charger les paquets pour l'utilisation
pacman::p_load(rio, tidyverse, here)
```
Notez que nous avons utilisé la syntaxe `pacman::p_load()` qui écrit explicitement le nom du paquet (**pacman**) avant le nom de la fonction (`p_load()`), reliés par deux deux points `::`. Cette syntaxe est utile car elle charge également le paquet **pacman** (en supposant qu'il soit déjà installé).
Il existe d'autres fonctions R **de base** que vous verrez souvent. La fonction R **de base** pour installer un paquet est `install.packages()`. Le nom du paquet à installer doit être fourni entre les parenthèses et *entre guillemets*. Si vous voulez installer plusieurs paquets en une seule commande, ils doivent être listés dans un vecteur de caractères `c()`.
Remarque : cette commande *installe* un paquet, mais ne le charge *pas* pour l'utiliser dans la séance en cours.
```{r, eval=F}
# Installer un seul paquet avec la base R
install.packages("tidyverse")
# Installer plusieurs paquets avec la base R
install.packages(c("tidyverse", "rio", "here"))
```
L'installation peut également être effectuée par pointer-cliquer en allant dans le panneau "Packages" de RStudio, en cliquant sur "Installer" et en recherchant le nom du paquet souhaité.
La fonction **base** de R pour **charger** un paquet à utiliser (après qu'il ait été installé) est `library()`. Elle ne peut charger qu'un seul paquet à la fois (une autre raison d'utiliser `p_load()`). Vous pouvez fournir le nom du paquet avec ou sans guillemets.
```{r, eval=F}
# Charger des paquets à utiliser, avec la base R
library(tidyverse)
library(rio)
library(here)
```
Pour vérifier si un paquet est installé et/ou chargé, vous pouvez afficher le panneau des paquets dans RStudio. Si le paquet est installé, il est affiché avec son numéro de version. Si sa case est cochée, il est chargé pour la séance en cours.
**Installation depuis Github**
Parfois, vous avez besoin d'installer un paquet qui n'est pas encore disponible sur CRAN. Ou peut-être que le paquet est disponible sur CRAN mais que vous voulez la *version de développement* avec de nouvelles fonctionnalités qui ne sont pas encore proposées dans la version CRAN publiée, plus stable. Ces versions sont souvent hébergées sur le site Web [github.com](https://github.com/) dans un "dépôt" de code libre et public. Pour en savoir plus sur Github, consultez la page du manuel intitulée $$Version control and collaboration with GitHub$$.
Pour télécharger des paquets R depuis Github, vous pouvez utiliser la fonction `p_load_gh()` de **pacman**, qui installera le paquet si nécessaire, et le chargera pour l'utiliser dans votre séance R actuelle. Les alternatives à l'installation incluent l'utilisation des paquets **remotes** ou **devtools**. Pour en savoir plus sur toutes les fonctions de **pacman**, consultez la [documentation du paquet](https://cran.r-project.org/web/packages/pacman/pacman.pdf).
Pour installer à partir de Github, vous devez fournir plus d'informations. Vous devez fournir :
1) L'ID Github (nom d'utilisateur) du propriétaire du dépôt.
2) Le nom du dépôt qui contient le paquet.
3) *(facultatif) Le nom de la "branche" (version de développement spécifique) que vous souhaitez télécharger*.
Dans les exemples ci-dessous, le premier mot entre guillemets est l'ID Github du propriétaire du dépôt. Après la barre oblique est le nom du dépôt (typiquement le nom du paquet).
```{r, eval=F}
# Installer/charger le paquet epicontacts depuis son dépôt Github
p_load_gh("reconhub/epicontacts")
```
Si vous voulez installer à partir d'une "branche" (version) autre que la branche principale, ajoutez le nom de la branche après un "\@", après le nom du dépôt.
```{r, eval=F}
# Installer la branche "timeline" du paquet epicontacts depuis Github
p_load_gh("reconhub/epicontacts@timeline")
```
S'il n'y a pas de différence entre la version Github et la version sur votre ordinateur, aucune action ne sera entreprise. Vous pouvez "forcer" une réinstallation en utilisant `p_load_current_gh()` avec le paramètre `update = TRUE`. Lisez plus sur **pacman** dans cette [vignette en ligne](http://trinker.github.io/pacman/vignettes/Introduction_to_pacman.html)
**Installation à partir d'un ZIP ou d'un TAR**
Vous pouvez installer le paquet à partir d'une URL :
```{r, eval=F}
packageurl <- "https://cran.r-project.org/src/contrib/Archive/dsr/dsr_0.2.2.tar.gz"
install.packages(packageurl, repos = NULL, type = "source")
```
Ou bien, le télécharger sur votre ordinateur dans un fichier zippé :
Option 1 : utiliser `install_local()` du paquet **remotes**.
```{r, eval=F}
remotes::install_local("~/Downloads/dplyr-master.zip")
```
Option 2 : en utilisant `install.packages()` du R de **base**, en fournissant le chemin d'accès au fichier ZIP et en définissant `type = "source"` et `repos = NULL`.
```{r, eval=F}
install.packages("~/Downloads/dplyr-master.zip",
type = "source",
repos = NULL)
```
### Syntaxe du code {.unnumbered}
Pour plus de clarté dans ce manuel, les fonctions sont parfois précédées du nom de leur paquet en utilisant le symbole `::` de la manière suivante : `nom_du_paquet::nom_de_la_fonction()`.
Une fois qu'un paquet est chargé pour une séance, ce style explicite n'est plus nécessaire. On peut simplement utiliser `nom_de_la_fonction()`. Cependant, écrire le nom du paquet est utile lorsqu'un nom de fonction est commun et peut exister dans plusieurs paquets (par exemple, `plot()`). L'écriture du nom du paquet chargera également le paquet s'il n'est pas déjà chargé.
```{r eval=FALSE}
# Cette commande utilise le paquet "rio" et sa fonction "import()" pour importer un jeu de données
linelist <- rio::import("linelist.xlsx", which = "Sheet1")
```
### Aide sur les fonctions {.unnumbered}
Pour en savoir plus sur une fonction, vous pouvez la rechercher dans l'onglet Aide du RStudio en bas à droite. Vous pouvez également lancer une commande comme `?thefunctionname` (mettez le nom de la fonction après un point d'interrogation) et la page d'aide apparaîtra dans le volet d'aide. Enfin, essayez de rechercher des ressources en ligne.
### Mettre à jour les paquets {.unnumbered}
Vous pouvez mettre à jour les paquets en les réinstallant. Vous pouvez également cliquer sur le bouton vert "Update" dans votre panneau "RStudio Packages" pour voir quels paquets ont de nouvelles versions à installer. Sachez que votre ancien code peut avoir besoin d'être mis à jour s'il y a une révision majeure du fonctionnement d'une fonction !
### Supprimer des paquets {.unnumbered}
Utilisez `p_delete()` de **pacman**, ou `remove.packages()` de **base** R. Alternativement, allez chercher le dossier qui contient votre bibliothèque et supprimez manuellement le dossier.
### Dépendances {.unnumbered}
Les paquets dépendent souvent d'autres paquets pour fonctionner. Ceux-ci sont appelés dépendances. Si une dépendance ne s'installe pas, le paquet qui en dépend peut également ne pas s'installer.
Voir les dépendances d'un paquet avec `p_depends()`, et voir quels paquets en dépendent avec `p_depends_reverse()`.
### Fonctions masquées {.unnumbered}
Il n'est pas rare que deux paquets ou plus contiennent le même nom de fonction. Par exemple, le paquet **dplyr** possède une fonction `filter()`, mais le paquet **stats** aussi. La fonction `filter()` par défaut dépend de l'ordre dans lequel ces paquets sont chargés pour la première fois dans la séance R - le dernier sera la fonction par défaut de la commande `filter()`.
Vous pouvez vérifier l'ordre dans votre panneau Environnement de R Studio - cliquez sur la liste déroulante pour "Global Environment" et voyez l'ordre des paquets. Les fonctions des paquets *inférieurs* dans cette liste déroulante masqueront les fonctions du même nom dans les paquets qui apparaissent plus haut dans la liste déroulante. Lors du premier chargement d'un paquet, R vous avertira dans la console si le masquage se produit, mais il est facile de ne pas le voir.
```{r out.width = "50%", fig.align = "center", echo=F}
knitr::include_graphics(here::here("images", "masking_functions.png"))
```
Voici comment vous pouvez corriger le masquage :
1) Spécifiez le nom du paquet dans la commande. Par exemple, utilisez `dplyr::filter()`\
2) Réorganisez l'ordre dans lequel les paquets sont chargés (par exemple, dans `p_load()`), et **démarrez une nouvelle séance R**.
### Détacher / décharger {.unnumbered}
Pour détacher (décharger) un paquet, utilisez cette commande, avec le nom correct du paquet et un seul deux-points. Notez que cela peut ne pas résoudre le masquage.
```{r, eval=F}
detach(package:NOM_DU_PAQUET_ICI, unload = TRUE)
```
### Installer une ancienne version {.unnumbered}
Consultez ce [guide](https://support.rstudio.com/hc/en-us/articles/219949047-Installing-older-versions-of-packages) pour installer une ancienne version d'un paquet particulier.
### Paquets suggérés {.unnumbered}
Voir la page [Paquets suggérés] pour une liste de paquets que nous recommandons pour l'épidémiologie quotidienne.
<!-- ======================================================= -->
## Scripts {#scripts}
Les scripts sont une partie fondamentale de la programmation. Ce sont des documents qui contiennent vos commandes (par exemple, des fonctions pour créer et modifier des jeux de données, imprimer des visualisations, etc). Vous pouvez sauvegarder un script et l'exécuter à nouveau ultérieurement. Le stockage et l'exécution de vos commandes à partir d'un script présentent de nombreux avantages (par rapport à la saisie des commandes une par une dans la "ligne de commande" de la console R) :
- Portabilité : vous pouvez partager votre travail avec d'autres personnes en leur envoyant vos scripts\
- Reproductibilité : pour que vous et les autres sachiez exactement ce que vous avez fait\
- Contrôle de version : pour que vous puissiez suivre les modifications apportées par vous-même ou par vos collègues\
- Commentaire/annotation : pour expliquer à vos collègues ce que vous avez fait
### Commentaire {.unnumbered}
Dans un script, vous pouvez également annoter ("commenter") votre code R. Les commentaires sont utiles pour expliquer à vous-même et aux autres lecteurs ce que vous faites. Vous pouvez ajouter un commentaire en tapant le symbole dièse (\#) et en écrivant votre commentaire après. Le texte commenté apparaîtra dans une couleur différente de celle du code R.
Tout code écrit après le \# ne sera pas exécuté. Par conséquent, placer un \# avant le code est également un moyen utile de bloquer temporairement une ligne de code ("commenter") si vous ne souhaitez pas la supprimer). Vous pouvez mettre en commentaire plusieurs lignes à la fois en les soulignant et en appuyant sur Ctrl+Shift+c (Cmd+Shift+c sur Mac).
```{r, eval = F}
# Un commentaire peut être sur une ligne par lui-même, ex.:
# Importer des données:
linelist <- import("linelist_raw.xlsx") %>% # un commentaire peut aussi venir après le code
# filter(age > 50)
# Il peut aussi être utilisé pour désactiver une ligne de code
count()
```
Vous trouverez ci-dessous quelques conseils essentiels pour commenter et annoter votre code :
- Commentez *ce que vous faites* et *pourquoi* vous le faites\
- Découpez votre code en sections logiques\
- Accompagnez votre code d'une description textuelle étape par étape de ce que vous faites (par exemple, des étapes numérotées).
### Style {.unnumbered}
Il est important d'être conscient de votre style de codage, surtout si vous travaillez en équipe. Nous préconisons le **tidyverse** [guide de style](https://style.tidyverse.org/). Il existe également des paquets tels que **styler** et **lintr** qui vous aident à vous conformer à ce style.
Quelques points très basiques pour rendre votre code lisible pour les autres:\
\* Lorsque vous nommez des objets, n'utilisez que des lettres minuscules, des chiffres et des traits de soulignement `_`, par exemple `mes_donnees`\
\* Utilisez fréquemment des espaces, y compris autour des opérateurs, par exemple `n = 1` et `age_nouveau <- age_vieillesse + 3`.
### Exemple de script {.unnumbered}
Vous trouverez ci-dessous un exemple d'un court script R. N'oubliez pas que plus vous expliquerez succinctement votre code dans les commentaires, plus vos collègues vous apprécieront !
```{r out.width = "100%", fig.align = "center", echo=F}
knitr::include_graphics(here::here("images", "example_script.png"))
```
<!-- ======================================================= -->
### R markdown {.unnumbered}
Un script R markdown est un type de script R dans lequel le script lui-même *devient* un document de sortie (PDF, Word, HTML, Powerpoint, etc.). Ce sont des outils incroyablement utiles et polyvalents, souvent utilisés pour créer des rapports dynamiques et automatisés. Même ce site Web et ce manuel sont produits à l'aide de scripts R markdown !
Il convient de noter que les utilisateurs débutants de R peuvent également utiliser R Markdown - ne vous laissez pas intimider !Pour en savoir plus, consultez la page du manuel consacrée aux $$Reports with R Markdown documents$$.
<!-- ======================================================= -->
### Carnets de notes R {.unnumbered}
Il n'y a pas de différence entre écrire dans un Rmarkdown et un R notebook. Cependant, l'exécution du document diffère légèrement. Voir ce [site](http://uc-r.github.io/r_notebook) pour plus de détails.
<!-- ======================================================= -->
### Shiny {.unnumbered}
Les applications/sites web Shiny sont contenus dans un script, qui doit être nommé `app.R`. Ce fichier comporte trois éléments :
1) Une interface utilisateur (ui)\
2) Une fonction serveur\
3) Un appel à la fonction `shinyApp`
Consultez la page du manuel sur $$Shiny dashboards$$, ou ce tutoriel en ligne : [Tutoriel Shiny](https://shiny.rstudio.com/tutorial/written-tutorial/lesson1/)
*Auparavant, le fichier ci-dessus était divisé en deux fichiers (`ui.R` et `server.R`)*.
### Repli du code {.unnumbered}
Vous pouvez replier des portions de code pour rendre votre script plus facile à lire.
Pour ce faire, créez un en-tête de texte avec #, écrivez votre en-tête, et faites-le suivre d'au moins 4 tirets (-), hachages (\#) ou égaux (=). Lorsque vous aurez fait cela, une petite flèche apparaîtra dans la "gouttière" à gauche (près du numéro de ligne). Vous pouvez cliquer sur cette flèche et sur le code situé en dessous jusqu'à ce que l'en-tête suivant se réduise et qu'une icône à double flèche apparaisse à sa place.
Pour développer le code, cliquez à nouveau sur la flèche dans la gouttière ou sur l'icône à double flèche. Il existe également des raccourcis clavier, comme expliqué dans la section [RStudio](#rstudio) de cette page.
En créant des en-têtes avec #, vous activerez également la table des matières au bas de votre script (voir ci-dessous) que vous pouvez utiliser pour naviguer dans votre script. Vous pouvez créer des sous-titres en ajoutant d'autres symboles, par exemple \# pour les titres primaires, \## pour les titres secondaires et \### pour les titres tertiaires.
Vous trouverez ci-dessous deux versions d'un exemple de script. À gauche, l'original avec des en-têtes commentés. À droite, quatre tirets ont été écrits après chaque en-tête, les rendant ainsi repliables. Deux d'entre eux ont été réduits, et vous pouvez voir que la table des matières en bas de page affiche maintenant chaque section.
```{r, out.width = c('50%'), fig.show='hold', echo=F}
knitr::include_graphics(here::here("images", "code_folding1.png"))
knitr::include_graphics(here::here("images", "code_folding2.png"))
```
D'autres zones de code qui sont automatiquement éligibles pour le pliage incluent les régions "accolées" avec des parenthèses `{ }` telles que les définitions de fonctions ou les blocs conditionnels (instructions "if else"). Vous pouvez en savoir plus sur le pliage du code sur le [site RStudio](https://support.rstudio.com/hc/en-us/articles/200484568-Code-Folding-and-Sections).
<!-- ======================================================= -->
<!-- ======================================================= -->
<!-- ======================================================= -->
## Répertoire de travail
Le répertoire de travail est l'emplacement du dossier racine utilisé par R pour votre travail - où R recherche et enregistre les fichiers par défaut. Par défaut, il enregistrera de nouveaux fichiers et sorties à cet emplacement et recherchera ici des fichiers (par exemple, des ensembles de données).
Le répertoire de travail apparaît dans le texte gris en haut du volet de la console RStudio. Vous pouvez également imprimer le répertoire de travail actuel en exécutant `getwd()` (laissez les parenthèses vides).
```{r out.width = "100%", fig.align = "center", echo=F}
knitr::include_graphics(here::here("images", "working_directory_1.png"))
```
### Approche recommandée {.unnumbered}
**Voir la page sur** $$R Projects$$ pour plus de détails sur notre approche recommandée pour gérer votre répertoire de travail.\
Un moyen commun, efficace et sans problème de gérer votre répertoire de travail et vos chemins de fichier consiste à combiner ces trois éléments dans un flux de travail du $$R projects$$ orienté comme expliqué ci-dessous:
1. Un projet R pour stocker tous vos fichiers (voir page sur $$R projects$$)\
2. Le paquet **here** pour localiser les fichiers (voir page sur $$Import and export$$)\
3. Le paquet **rio** pour importer ou exporter des fichiers (voir page sur $$Import and export$$)
<!-- ======================================================= -->
### Définir le répertoire de travail par commande {.unnumbered}
Jusqu'à récemment, de nombreuses personnes apprenant R ont appris à commencer leurs scripts avec une commande `setwd()`. Veuillez plutôt envisager d'utiliser un flux de travail orienté par $$R Projects$$ et lire les [raisons de ne pas utiliser `setwd()`](https://www.tidyverse.org/blog/2017/12/workflow-vs-script/).
En bref, votre travail devient spécifique à votre ordinateur, les chemins de fichier utilisés pour importer et exporter des fichiers deviennent "cassants", ce qui entrave gravement la collaboration et l'utilisation de votre code sur tout autre ordinateur. Heureusement il existe des alternatives faciles!
Comme indiqué ci-dessus, bien que nous ne recommandons pas cette approche dans la plupart des cas, vous pouvez utiliser la commande `setwd()` avec le chemin du fichier de dossier souhaité dans les citations, par exemple:
```{r, eval=F}
setwd("C:/Documents/R Files/My analysis")
```
[***DANGER:*** Définition d'un répertoire de travail avec `setwd()` *peut* être "cassant" si le chemin de fichier est spécifique à un ordinateur. Au lieu de cela, utilisez des chemins de fichier par rapport à un répertoire racine du projet R (avec le paquet **here**).]{style="color:red;"}
<!-- ======================================================= -->
### Définir manuellement le répertoire de travail {.unnumbered}
Pour définir le répertoire de travail manuellement (l'équivalent graphique du `setwd()`), cliquez sur le menu déroulant "Session" et accédez à "Set Working Directory", puis "Choose Directory". Cela définira le répertoire de travail pour cette scéance spécifique de R. Remarque: Si vous utilisez cette approche, vous devrez le faire manuellement chaque fois que vous ouvrez Rstudio.
<!-- ======================================================= -->
### Définir le répertoire de travail dans un projet R {.unnumbered}
Si vous utilisez un projet R, le répertoire de travail sera par défaut dans le dossier racine du projet R qui contient le fichier `.rproj`. Cela s'appliquera si vous ouvrez RStudio en cliquant sur le projet R (le fichier avec l'extension `.rproj`).
<!-- ======================================================= -->
### Répertoire de travail dans un script R Markdown {.Unnumbered}
Dans un script R Markdown, le répertoire de travail par défaut est le dossier ou le fichier RMarkdown (`.rmd`) est enregistré. Si vous utilisez un projet R et le paquet **here**, cela ne s'applique pas et le répertoire de travail sera `here()`, comme expliqué dans la page $$R projets$$.
Si vous souhaitez modifier le répertoire de travail d'une dossier RMarkdown autonome (qui ne fait pas partie d'un projet R), et vous utilisez `setwd()`, cela ne s'appliquera qu'à ce morceau de code spécifique. Pour modifier tous les morceaux de code dans une dossier RMarkdown, modifiez le morceau de configuration pour ajouter le paramètre `root.dir =`, comme ci-dessous:
```{r, eval=F}
knitr::opts_knit$set(root.dir = 'desired/directorypath')
```
Il est beaucoup plus facile d'utiliser simplement le script RMarkdown dans un projet R et d'utiliser le paquet **here**.
<!-- ======================================================= -->
### Fournir des chemins de fichier {.unnumbered}
La source de frustration la plus commune pour un débutant R (au moins sur un ordinateur avec Windows) est de saisir un chemin de fichier pour importer ou exporter des données. Il existe une explication approfondie sur la meilleure façon de saisir les chemins de fichier de saisie dans la page $$Import and export$$, mais voici quelques points clés:
**Chemins cassés**
Vous trouverez ci-dessous un exemple de chemin de fichier "absolute" avec un "adresse complète". Ceux-ci se casseront probablement s'ils sont utilisés par un autre ordinateur. Une exception est si vous utilisez un dossier sur un réseau partagé.
C:/Utilisateurs/Nom/Document/Logiciels analytiques/R/Projets/Analyse2019/data/mars2019.csv
**Direction de la barre oblique**
*Si vous saisissez un chemin de fichier, soyez conscient de la direction des barres obliques.* Utilisez *des barres obliques vers l'avant* (`/`) pour séparer les composants, par exemple `Data/Provincial.csv`. Le défaut pour les ordinateurs avec Windows est de séparer les composants du chemin avec *des barres obliques en arrière* (`\\`). Vous devrez donc modifier la direction de chaque barre oblique. Si vous utilisez le paquet **here** comme décrit dans la page $$R projects$$, la direction des barres obliques n'est pas un problème.
**Chemins de fichiers relatifs**
Nous recommandons généralement de utiliser des fichiers avec chemins "relatifs" - c'est-à-dire le chemin *par rapport à* la racine de votre projet R. Vous pouvez le faire en utilisant le paquet **here** comme expliqué dans la page $$R projects$$. Un chemin de fichiers relatif peut ressembler à ceci:
```{r, eval=F}
# Importer csv Linelist à partir de données/listes linéare/propres/sous-dossiers d'un projet R
linelist <- import(here("data", "clean", "linelists", "marin_country.csv"))
```
Même si vous utilisez des chemins de fichiers relatifs dans un projet R, vous pouvez toujours utiliser des chemins absolus pour importer/exporter des données en dehors de votre projet R.
<!-- ======================================================= -->
## Objets {#objets}
Tout dans R est un objet, et R est une langue "orienté sur l'objet". Les sections suivantes expliquent:
- Comment créer des objets (`<-`)
- Types d'objets (par exemple, trames de données, vecteurs ..)\
- Comment accéder à des sous-parties d'objets (par exemple, des variables dans un jeu de données)\
- Classes d'objets (ex. numérique, logique, nombres entieres, double, caractère, facteur)
<!-- ======================================================= -->
### Tout est un objet {.unnumbered}
*Cette section est adaptée du [projet R4Epis](https://r4epis.netlify.app/training/r_basics/objects/).*\
Tout ce que vous stockez dans R - des ensembles de données, des variables, une liste de noms de villages, un nombre total de population, même des sorties telles que des graphiques - sont des **objets** qui sont **attribués à un nom** et **peuvent être référencés** dans les commandes ultérieures.
Un objet existe lorsque vous lui avez attribué une valeur (voir la section d'attribution ci-dessous). Lorsqu'une valeur lui est attribuée, l'objet apparaît dans l'environnement (voir le volet supérieur droit de RStudio). Il peut alors être exploité, manipulé, modifié et redéfini.
<!-- ======================================================= -->
### Définir des objets (`<-`) {.unnumbered}
**Créez des objets *en leur attribuant une valeur* avec l'opérateur `<-`.** Vous pouvez considérer l'opérateur d'affectation`<-` comme les mots "est défini comme". Les commandes d'affectation suivent généralement un ordre standard:
**`nom_objet <- valeur`** (ou processus/calcul qui produit une valeur)
Par exemple, vous souhaiterez peut-être enregistrer la semaine de rapport épidémiologique en cours en tant qu'objet de référence dans le code ultérieur. Dans cet exemple, l'objet `semaine_en_cours` est créé lorsqu'il reçoit la valeur `"2018-W10"` (les guillemets en font une valeur de caractère). L'objet `semaine_en_cours` apparaîtra alors dans le volet Environnement de RStudio (en haut à droite) et pourra être référencé dans les commandes ultérieures.
Voir les commandes R et leur sortie dans les cases ci-dessous.
```{r basics_objects_assignment}
# Créer l'objet semaine_en_cours en lui attribuant une valeur:
semaine_en_cours <- "2018-W10"
# Imprime la valeur actuelle de l'objet semaine_en_cours dans la console:
semaine_en_cours
```
[***NOTE:*** Notez que le `[1]` dans la sortie de la console R indique simplement que vous visualisez le premier élément de la sortie]{style="color: black;"}