-
Notifications
You must be signed in to change notification settings - Fork 0
/
base_R.qmd
534 lines (386 loc) · 25.1 KB
/
base_R.qmd
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
---
title: "<span style='font-family: Boska; font-size: 2.75rem; font-weight: 800;'>Pré-requis R</span>"
execute:
eval: false
echo: true
lang: fr
---
## Introduction
La compréhension et la reproduction des scripts PMSI R supposent :
\# un environnement R de travail opérationnel avec les packages R appelés dans les scripts (généralement des packages du [tidyverse](https://www.tidyverse.org/){target="_blank"} et le package de données [refpmsi](https://denisgustin.github.io/refpmsi/index.html){target="_blank"}
\# une pratique minimale de R
\# de disposer de données PMSI sous forme de tibbles exploitables.
Nous vous invitons à consulter le **[Guide des scripts](guide_post.qmd)**
Les explications proposées ci-dessous sont volontairement simplifiées, avec donc quelques abus de langage assumés[^1]
Les supports et ressources en ligne pour apprendre et pratiquer R sont innombrables.
Quelques ressources en français récentes, didactiques et accessibles pour apprendre R :
[Introduction à R et au tidyverse par Julien Barnier](https://juba.github.io/tidyverse/index.html){target="_blank"}
[analyse-R par Joseph Larmarange](https://larmarange.github.io/analyse-R/){target="_blank"}
Ressources R et PMSI :
[Y a du PMSI dans R](http://pmsidansr.senis.org/){target="_blank"}
[Package refpmsi](https://denisgustin.github.io/refpmsi/index.html){target="_blank"}
[Contact pour toute question](https://www.lespmsi.com/contact-pmsisoft){target="_blank"} (avec l'objet "Question formation Data PMSI avec R")
## Installer R
R s'installe sous Windows comme un simple exécutable (comme DRUIDES ou GENRHA par exemple).
[Télécharger R dans sa dernière version](https://cloud.r-project.org/bin/windows/base/){target="_blank"}
Accepter les options par défaut jusqu’à la fin de l’installation.
Nous recommandons une version de R >= à la version 4.1.3 de mars 2022.
[Historique des versions de R](https://cran.r-project.org/bin/windows/base/old/){target="_blank"}
## Installer R Studio
**Après** avoir installé R, nous installons R Studio qui est un environnement de développement (IDE) de référence pour R.
Plus exactement, nous allons télécharger la version open source de R Studio, appelée "R Studio Desktop".
R Studio Desktop s'installe comme un exécutable.
[Télécharger R Studio Desktop](https://posit.co/download/rstudio-desktop/){target="_blank"}
Nous recommandons une version de R Studio Desktop >= version 2022.07.02
[Historique des versions de R Studio Desktop](https://docs.posit.co/previous-versions/rstudio/){target="_blank"}
A ce stade, vous disposez d'une icône R Studio sur votre bureau pour ouvrir R Studio.
[Tuto avec copies écrans pour installer R et R Studio](http://pmsidansr.senis.org/2022/06/15/installation-r-rstudio/){target="_blank"}
[Tuto pour découvrir R Studio](https://openclassrooms.com/fr/courses/4525256-initiez-vous-au-langage-r-pour-analyser-vos-donnees/6250851-prenez-en-main-r-et-r-studio){target="_blank"}
[Autre tuto](https://larmarange.github.io/analyse-R/premier-contact.html){target="_blank"}
Autre IDE pour développer en R : [Visual Studio Code](https://code.visualstudio.com/){target="_blank}
## Créer un projet et un premier fichier .R
### Créer un premier projet
Nous allons maintenant créer un projet sous R Studio que l'on propose d'appeler `formation_data_pmsi`.
Ce projet va regrouper tous les fichiers .R et autres informations en lien avec les exerices, données et scripts de la formation.
**Première étape** : on crée (à priori à la racine C:), un répertoire avec l'intitulé `formation_data_pmsi`.
**Seconde étape** : dans R Studio, on crée le projet `formation_data_pmsi` en le rattachant au répertoire que l'on vient de créer à la première étape via File > New Project > Existing Directory
[Un tuto](https://juba.github.io/tidyverse/05-organiser.html#projets){target="_blank"}
[Autre tuto](https://www.book.utilitr.org/rproject.html){target="_blank"}
Désormais, une fois ouvert R Studio, on ouvrira ce projet `formation_data_pmsi` via File > Open Project
### Mon premier fichier .R
Nous créons un premier fichier .R dans lequel nous allons sauvegarder les codes R des requêtes et analyses PMSI de la formation.
Pour créer un fichier .R : File > New File > R Script
Un fichier "untitled1" apparaît dans le quadrant haut gauche (le quadrant éditeur de code).
En cliquant sur l'icône "Sauvegarder" de ce quadrant, vous saisissez le nom du fichier, par exemple "intro.R"
Premières lignes de code (à copier/coller)
```{r}
#| label: first_script
type_data_learning
# les lignes de commentaires commencent par #
# cliquer sur alt + entrée à la fin chaque ligne de code pour exécuter la ligne
# première saisie. Il s'agit du très classique jeu de données iris, natif dans R
# le jeu de données s'affiche dans la console
iris
# appel d'une fonction
# nrow() = fonction native de R calculant le nombre de lignes d'un tableau de données
nrow(iris)
# <- permet d'attribuer une valeur à une variable (raccourci R Studio pour <- : alt + 6)
# il y a des bonnes pratiques de nommage des variables : elles sont appliquées dans cette note
a <- 1
a
```
Penser à sauvegarder votre script R régulièrement et, à minima, avant de quitter R Studio.
En quittant R Studio, ne jamais sauvegarder le .RData si R Studio vous le demande
[Un tuto](http://pmsidansr.senis.org/2022/06/15/un-premier-programme-en-r/)
[Contactez-nous pour toute question](https://www.lespmsi.com/contact-pmsisoft){target="_blank"} (avec l'objet "Question formation Data PMSI avec R")
## Minimum de R à connaître
Il y a 4 concepts à connaître : les types de données, les vecteurs, les data frames ou tibbles et les lists
Nous les exposons ci-dessous, à minima, avec des exemples issus de données simili PMSI, à exécuter dans le fichier intro.R
**Type de données**
Chaque information (un code CIM, un code d'UM, un initulé, une valorisation T2A, un nombre d'actes, la catégorisation d'âge "adulte" versus "moins 18 ans", un seuil, ...) relève d'un type de données.
Il y a 4 types principaux de données (logical, character, integer, numeric) que nous illustrons ci-dessous[^5]
```{r}
#| label: type_data_learning
# type logical
# 2 valeurs possibles : TRUE ou FALSE
# exemple. Pour indiquer qu'on excluera les moins de 18 ans d'une analyse
age_moins_18 <- FALSE
age_moins_18
# type character
# valeurs avec du texte. Bien indiquer les ""
code_cim <- "S42700"
code_cim
# type integer
# valeurs entières
seuil_acte <- 4
seuil_acte
# type numeric
# valeurs réelles. Avec . au lieu de , pour les décimals
valo_t2a <- 13467.89
valo_t2a
```
**Vecteur**
Un vecteur est un ensemble de valeurs [du même type]{.underline}.
On parlera ainsi d'un vecteur logique, d'un vecteur character, etc...
```{r}
#| label: vector_learning
# un vecteur est créé par la fonction c()
## ici un vecteur de codes UM
mes_um <- c("UM01","UM02","UM03","UM04")
mes_um
# nombre d'élements d'un vecteur avec la fonction length()
length(mes_um)
# extraction d'un élément par sa position
## ici extraction du 2eme élément du vecteur
mes_um[2]
# extraction de plusieurs éléments via un vecteur des positions à extraire
## ici extraction des positions 2 et 4
positions_recherchees <- c(2,4)
mes_um[positions_recherchees]
# ou plus directement
mes_um[c(2,4)]
# une donnée manquante est indiquée par NA (comme Non Available)
destination_um <- c(NA,NA,2,7,NA)
destination_UM[1]
destination_UM[3]
# on peut attribuer un nom à chaque éléments du vecteur avec la fonction names()
noms_um <- c("Ortho","Pédiatrie","Gynéco","Urgences")
names(mes_um) <- noms_um
mes_um
```
**Data frame/tibble**
Un data frame ou tableau de données est une liste de vecteurs indépendants.
Un data frame est donc constitué de colonnes de même longueur (même nombre de lignes) qui peuvent être de types différents.
Le jeu de données [`mini_fake_dataset_mco`](dataset_mco.qmd), librement téléchargeable (voir ci-dessous), est ainsi un data frame composé de 27 colonnes.
Les référentiels du package de données [refpmsi](https://denisgustin.github.io/refpmsi/index.html){target="_blank"} (par exemple le référentiel `cim` de la CIM-10 à usage PMSI de 2019 à 2022) sont des data frames.
Abréviation courante : df
Un tibble est un data frame "enrichi" dans l'environnement du tidyverse[^3].
En pratique, parce qu'on travaille essentiellement avec les packages du tidyverse, on parlera de tibble (abréviation : tbl)
On parlera indifféremment de colonnes ou de variables : une variable d'un tibble correspond à une colonne
**List**
Une list, au sens R, est une collection de structures de données (valeurs uniques, vecteurs, tibbles, list).
Une image pour visualiser : une list est une commode dont chaque tiroir contient des objects différents, des pulls dans le premier tiroir, des assiettes dans le second tiroir, rien dans le troisième, un seul livre dans le quatrième.
Une list est donc la structure de données la plus souple, la plus puissante, mais aussi la plus complexe à manipuler.
Le jeu de données [`fake_dataset_mco`](dataset_mco.qmd) des formations MCO est ainsi une list de tibbles (un tbl simili partie fixe des RSS, un tbl simili RSA, un tbl simili actes CCAM, un tble simili DAS, un tbl de DMI, un tbl simili ficium) : nous manipulons donc un seul objet au lieu de 6 objets.
## Installer et charger des packages
De manière simplifiée, on peut dire qu'un package est une réunion cohérente de fonctions et de données que l'on va pouvoir utiliser en appelant ses fonctions et ses données sans avoir à se préoccuper de la façon dont elles sont codées.
Une fois installé, un package sera à charger à chaque nouvelle session R Studio.
Les packages d'intérêt général et validés après une série poussée de tests sont disponibles sur le [CRAN](https://cran.r-project.org/index.html). C'est essentiellement parmi ces packages que nous allons faire notre marché.
L'installation d'un package est réalisée une fois pour toute (sauf mise à jour du package).
En revanche, à chaque nouvelle session R Studio, nous allons devoir charger les packages nécessaires (voir ci-dessous "Chargement des packages").
### Le tidyverse
Les packages les plus utiles dans les formations **Data PMSI avec R** sont les packages d'une collection cohérente de packages appelée [tidyverse](https://www.tidyverse.org/){target="_blank"}.
Le tidyverse est une sorte méta-package. En chargeant le tidyverse, on charge tous les packages du tidyverse en une fois.
Principaux packages du tidyverse utilisés en analyse PMSI :
- dplyr (package qui fournit les fonctions de base pour résoudre les problèmes de manipulation de données les plus courants comme filtre, trier, sélectionner des colonnes, ajouter une colonne, compter des lignes, ...)
- tidyr (package pour créer des structures "bien rangées" - tidy en anglais -)
- stringr (package pour manipuler des chaînes de caractères)
- tibble (package pour manipuler spécifiquement les tibbles)
- ggplot2 (package pour produire des graphiques)
Dans le tidyverse, on trouve aussi les packages lubridate (pour manipuler des dates), purrr (pour programmation fonctionnelle), forcats (pour manipuler des facteurs), ...
Installation des packages du tidyverse
```{r}
#| label: tidyverse_install
# suffisant pour les formations [Requêtes MCO], [Requêtes SSR] et [Requêtes PSY]
vect_pkg <- c("tidyverse")
# la fonction install.packages() installe la dernière version des packages du tidyverse
install.packages(vect_pkg)
```
### Le package refpmsi
refpmsi est un package de référentiels PMSI qui permet de récupérer et travailler avec les référentiels PMSI annualisés et normalisés pour R.
Le chargement de ce package qui n'est pas sur le CRAN est spécifique.
Voir la [documentation de refpmsi](https://denisgustin.github.io/refpmsi/index.html){target="_blank"} pour installer refpmsi.
### Autres packages CRAN
En fonction des formations **Data PMSI avec R**, on peut installer d'autres packages du CRAN :
- gt, gtExtras pour les formations [Tableaux]
- ggrepel, ggtext pour les formations [Graphiques]
- data.table pour la formation Requêtes MCO [Avancé]
La liste des packages et fonctions utilisés dans une formation est indiquée dans la présenttion de la formation concernée.
### Chargement des packages
Maintenant que nous avons installé les packages nécessaires, nous allons les charger.
Le code ci-dessous est donc à exécuter à chaque nouvelle session de travail, raison pour laquelle on dispose généralement en tête du fichier .R sur lequel on travaille un code, comme celui proposé ci-dessous, pour charger ces packages.
```{r}
#| label: dataset_install_package
# Charger un package. Ici le package dplyr
library(dplyr)
# Code proposé pour charger rapidement plusieurs packages
# A copier/coller tel quel
# lapply est une fonction qui va "appliquer" la fonction library à chaque élément du vecteur list_packages
# la fonction invisible() est un confort pour ne pas afficher des informations
list_packages <- c("dplyr","tibble","tidyr","stringr","jsonlite","refpmsi")
invisible(lapply(list_packages, library, character.only = TRUE))
# Alternative avec le package pacman
pacman::p_load(char = list_packages)
```
## Charger un jeu de données
La traduction anglaise de jeu de données est dataset. On parlera donc indifféremment désormais de jeux de données ou de dataset.
Pour tester le bon fonctionnement et être opérationnel en début de formation, nous avons construit et mettons à disposition [`mini_fake_dataset_mco`](dataset_mco.qmd){target="_blank"}, un mini jeu de données simili PMSI MCO, cohérent avec les jeux de données mis à disposition pour une formation **Data PMSI avec R**.
Le jeu [`mini_fake_dataset_mco`](dataset_mco.qmd){target="_blank"} (qui est simplement un fichier texte) est à télécharger librement et à déposer dans un sous-répertoire `data` (on pourrait l'appeler autrement) à créer dans le répertoire `formation_data_pmsi`.
Puis nous exécutons le code ci-dessous
```{r dataset_upload_learning}
# On a chargé la suite de packages list_packages : voir étape 5
# Le jeu est chargé dans la variable jeu qui est un dataframe
jeu <- jsonlite::fromJSON("data/mini_fake_dataset_mco.json")
# on vérifie que jeu est bien un data frame avec la fonction is.data.frame()
is.data.frame(jeu)
# pour faciliter son exploitation, on passe ce jeu en tibble avec la fonction as_tibble du package tibble::
# ici on écrase le df jeu par le nouveau tbl jeu qui a le même nom de variable
jeu <- tibble::as_tibble(jeu)
# on vérifie que le jeu est bien chargé
# la fonction glimpse() du package dplyr fournit un résumé pratique d'un dataset
dplyr::glimpse(jeu)
```
Le résultat est le suivant :
```{r dataset_test_eval_learning}
#| eval: true
#| echo: false
jeu <- jsonlite::fromJSON("data/mini_fake_dataset_mco.json")
dplyr::glimpse(jeu)
```
Pour les formations, nous mettons à disposition des participants le jeu de données [`fake_dataset_mco`](dataset_mco.qmd) plus fourni avec plus de lignes et différents tibbles.
Nous recommandons aux participants médecins DIM de récupérer les données PMSI de leurs établissements au format JSON via l'[accès Standard de PMSISoft](https://www.pmsisoft.com/acces_pmsisoft_mco.html){target="_blank"}
Les noms des variables de nos fake dataset PMSI sont ceux des exports de l'accès Standard de PMSISoft en JSON : les médecins DIM peuvent donc ainsi coder en R, pendant la formation, sur les données PMSI de leurs établissements.
## Le pipe `%>%` et son fonctionnement
Comprendre ce qu'est et comment fonctionne le pipe `%>%` est fondamental.
C'est ce qui permet de construire des scripts lisibles, complexes, testables et maintenables.
L'idée de base est la suivante : puisque, pour la quasi-totalité des fonctions R et spécialement pour les fonctions du `tidyverse`, le premier argument de ces fonctions est un data frame (sur lequel va s'appliquer la fonction)[^4] et qu'un script consiste, dans son principe, à **enchaîner** des traitements successifs, on va passer directement le résultat de chaque traitement (qui est donc un tibble modifié) au traitement suivant via le pipe `%>%`
Illustrons avec le `mini_fake_dataset_mco` que nous avons chargé à l'étape 6 en lui appliquant quelques traitements simples (voir étape 8 "Quelques manipulations simples" ci-dessous).
Première approche sans le `%>%` : on enregistre le résultat de chaque traitement dans une variable
```{r pipe_1_learning}
# on reprend la variable jeu créée lors de l'étape 6
# premier traitement : on filtre les RUM groupé en 04M023 avec la fonction filter() du package dplyr
# on préfixe les fonctions avec leur package en codant dplyr::filter()
# on pourrait coder aussi filter() sans référence au package
# on constate que le premier argument de la fonction filter() est bien un data frame,
# ici jeu qui est notre jeu de données
jeu1 <- dplyr::filter(jeu, ghm == "04M203")
jeu1
# second traitement : on sélectionne quelques variables
jeu2 <- dplyr::select(jeu1, ghm,nas,no_rum,age,dp,dr,nb_das,nb_ccam,date_entree_um,date_sortie_um)
jeu2
# troisième traitement : on transforme les 2 variables date_entree_um et date_sortie_um au format date
jeu3 <- dplyr::mutate(jeu2, date_entree_um = as.Date(date_entree_um),
date_sortie_um = as.Date(date_sortie_um))
jeu3
# 4eme traitement : on créé la variable cmd en récupérant les 2 premières positions du ghm
jeu4 <- dplyr::mutate(jeu3, cmd = stringr::str_sub(ghm,1,2))
jeu4
```
Constat :
On a un tibble d'entrée (`jeu`) et on veut un tibble résultat.
Avec cette approche, on génère 4 tibble pour arriver au résultat voulu.
Sachant qu'un script classique PMSI (exemple : produire un case mix simple) va se composer d'une dizaine de traitements et qu'on enchaîne souvent plusieurs suites de traitements, on voit bien que cela devient très rapidement ingérable et illisible avec des dizaines de résultats intermédiaires et des risques constants d'erreur de saisie.
Deuxième approche : composition de fonctions
```{r pipe_2_learning}
# on reprend les 4 traitements de la 1ère approche
# en partant du dernier traitement dont le tibble est le résultat
# puis du 3eme traitement, etc...
dplyr::mutate(dplyr::mutate(dplyr::select(dplyr::filter(jeu, ghm == "04M203"), ghm,nas,no_rum,age,dp,dr,nb_das,nb_ccam,date_entree_um,date_sortie_um),
date_entree_um = as.Date(date_entree_um),
date_sortie_um = as.Date(date_sortie_um)),
cmd = stringr::str_sub(ghm,1,2))
```
Constat :
Cela se passe de commentaires !
L'approche avec le pipe `%>%
```{r pipe_3_learning}
# le tibble final est directement enregistré dans une variable que l'on nomme ici jeu_resultat
# le raccourci R Studio pour le pipe %>% est ctrl + shift (la flêche vers le haut) + M
jeu_resultat <- dplyr::filter(jeu, ghm == "04M203") %>%
# dans la fonction dplyr::select(), il n'y a plus de premier argument affiché
# car le pipe a transféré dans le premier argument de la fonction dplyr::select() le tibble
# issu du traitement de la ligne précédente
dplyr::select(ghm,nas,no_rum,age,dp,dr,nb_das,nb_ccam,date_entree_um,date_sortie_um) %>%
# même fonctionnement avec la fonction dplyr::mutate() dont le premier argument "invisible"
# est le tibble produit par ce qui précède le %>%
# la fonction dplyr::mutate() permet de créer ou modifier des variables
dplyr::mutate(date_entree_um = as.Date(date_entree_um),
date_sortie_um = as.Date(date_sortie_um)) %>%
# la fonction strinr::str_sub() permet d'extraire une partie d'une suite de caractères
dplyr::mutate(cmd = stringr::str_sub(ghm,1,2))
jeu_resultat
# si je veux uniquement les 2 premiers traitements
# je mets en commentaire les lignes inutilisées : très souple pour "jouer" avec un script
jeu_resultat <- dplyr::filter(jeu, ghm == "04M203") %>%
dplyr::select(ghm,nas,no_rum,age,dp,dr,nb_das,nb_ccam,date_entree_um,date_sortie_um)
# dplyr::mutate(jeu2, date_entree_um = as.Date(date_entree_um), date_sortie_um = as.Date(date_sortie_um)) %>%
# dplyr::mutate(jeu3, cmd = stringr::str_sub(ghm,1,2))
jeu_resultat
# autre intérêt : je réitère très facilement pour un autre ghm
# en changeant juste à un seul endroit (dans le filter) le code ghm
jeu_resultat <- dplyr::filter(jeu, ghm == "19M024") %>%
dplyr::select(ghm,nas,no_rum,age,dp,dr,nb_das,nb_ccam,date_entree_um,date_sortie_um) %>%
dplyr::mutate(date_entree_um = as.Date(date_entree_um), date_sortie_um = as.Date(date_sortie_um)) %>%
dplyr::mutate(cmd = stringr::str_sub(ghm,1,2))
jeu_resultat
```
Constat :
Le code est lisible : on voit bien ce qui se passe dans chaque ligne.
Je peux documenter chaque ligne.
Je n'ai que 2 tibble : le tibble d'origine qui ne bouge pas et le tibble résultat.
Je peux tester une suite de lignes de code en supprimant le pipe à l'endroit voulu.
**Je peux modifier un traitement sans modifier les autres ni tout reprendre** (manipulation très fréquente en PMSI où on va tester des hypothèses et des codages à la volée).
## Quelques manipulations simples
A partir du jeu `mini_fake_dataset_mco` que nous avons chargé à l'étape 6, quelques manipulations basiques avec des fonctions du tidyverse permettant de voir aussi le fonctionnement du pipe `%>%`
### fonction dplyr::filter()
Pour filtrer des lignes[^6]
```{r code_filter_learning}
# filter() fonctionne avec les valeurs logiques.
# ici no_um == "um01" teste cette condition sur chaque ligne, donc avec une réponse attendue TRUE ou FALSE
# si le code UM est bien "um01", no_um == "um01 produit la valeur TRUE et donc filter retient la ligne
jeu %>% dplyr::filter(no_um == "um01")
# 2 filtrages successives
jeu %>%
dplyr::filter(no_um == "um01") %>%
dplyr::filter(age >= 75)
# ou plus directement les 2 filtrages dans un seul traitement où & est le ET logique
jeu %>% dplyr::filter(no_um == "um01" & age >= 75)
```
### fonction dplyr::select()
Pour sélectionner des variables
```{r code_select_learning}
# Sélection de quelques variables par leur nom
jeu %>% dplyr::select(ghm,nas,no_rum,dp)
# en PMSI, on a souvent beaucoup de colonnes.
# on verra dans la formation comment sélectionner intelligemment parmi beaucoup de variables
```
### fonction dplyr::mutate()
Pour ajouter ou modifier des variables
```{r code_mutate_learning}
# création d'un variable cmd
jeu %>% dplyr::mutate(cmd = stringr::str_sub(ghm,1,2))
```
### fonction dplyr::arrange()
Pour trier selon une ou plusieurs colonnes
```{r code_arrange_learning}
# Tri ascendant sur l'âge après sélection de variables
jeu %>%
dplyr::select(ghm,nas,no_rum,no_um,dp,age) %>%
dplyr::arrange(age)
# tri descendant avec l'option desc() dans arrange()
jeu %>%
dplyr::select(ghm,nas,no_rum,no_um,dp,age) %>%
dplyr::arrange(desc(age))
```
### exercices
**Codes CIM-10 autorisés en DP**
```{r code_cim_autorise_dp_learning}
# Récupération du référentiel CIM-10
cim_10 <- refpmsi::refpmsi("cim")
dplyr::glimpse(cim_10)
cim_dp_2022 <- cim_10 %>%
# sélection des variables qui nous intéressent
dplyr::select(cim_code,cim_tmco,annee_pmsi,cim_lib) %>%
dplyr::filter(annee_pmsi == "2022") %>%
# rappel : les codes autorisés en DP ont la valeur 0
# (voir le kit de la nomenclature CIM PMSI sur le site de l'ATIH)
dplyr::filter(cim_tmco == 0)
# résultat : 13 357 codes
cim_dp_2022 %>% View
# Et les codes CIM-10 non autorisés en DP
cim__non_dp_2022 <- cim_10 %>%
dplyr::select(cim_code,cim_tmco,annee_pmsi,cim_lib) %>%
dplyr::filter(annee_pmsi == "2022") %>%
dplyr::filter(cim_tmco != 0)
cim_non_dp_2022 %>% View
```
**RUM le plus long d'une sous CMD**
```{r code_rum_sous_cmd_duree_learning}
jeu1 <- jeu %>%
dplyr::select(nas,no_rum,ghm,date_sortie_um,date_entree_um) %>%
dplyr::mutate(sous_cmd = stringr::str_sub(ghm,1,3)) %>%
dplyr::mutate(date_sortie_um = as.Date(date_sortie_um), date_entree_um = as.Date(date_entree_um)) %>%
dplyr::mutate(duree_rum = date_sortie_um - date_entree_um) %>%
dplyr::filter(sous_cmd == "04M") %>%
dplyr::mutate(duree_rum = date_sortie_um - date_entree_um) %>%
dplyr::filter(duree_rum == max(duree_rum))
# résultat : le rum 2 du nas 411 avec 34 journées PMSI
jeu1
```
[Contact pour toute question](https://www.lespmsi.com/contact-pmsisoft){target="_blank"} (avec l'objet "Question formation Data PMSI avec R")
[^1]: par exemple, on ne distingue pas les notions de types, modes et classes de données, mais on se réfère au sens courant du mot type de données.
[^2]: depuis mai 2021 et la version 4.1.0 de R, il existe |> nouveau pipe natif dans R, alternative à %>% du tidyverse
[^3]: on ne discutera pas ici des différences entre df et tbl
[^4]: voir par exemple la documenter de la fonction très courante [dplyr::filter](https://dplyr.tidyverse.org/reference/filter.html){target="_blank"} où le premier argument (.data) est bien le data frame sur lequel le filter va s'appliquer.
[^5]: il y a aussi les données `Date` par exemple
[^6]: [documentation fonction filter()](https://dplyr.tidyverse.org/reference/filter.html){target="_blank"}