Learning R Programming Language With WikiBook (PDF) (FR)

28/11/2021 00:43 Programmer en R — Wikilivres
R est un langage de programmation dédié aux statistiques.
Table des matières

Introduction
Faire ses premiers pas
Installer R
Choisir son environnement de travail
Installer des librairies
Se documenter
Manipulation et mise en forme des données
Manipuler les nombres
Manipuler les vecteurs
Manipuler les chaînes de caractères
Manipuler les facteurs
Manipuler les dates et les heures
Manipuler un tableau de données
Manipuler une liste
Importation et exportation des données
Importer un fichier CSV
Résoudre les problèmes d'encodage des caractères
Importer un fichier TSV
Importer un fichier texte à largeur fixe
Importer des données depuis un tableur
Import un fichier JSON
Extraire des données d'une page web
Visualisation de données
Comprendre la grammaire des graphiques
Représenter une carte
Visualiser une carte choroplèthe
Modélisation statistique
Estimer un modèle de régression linéaire
Estimer un modèle de régression circulaire
Communication
Programmation avancée
Programmer une boucle
Programmer une fonction
Outils mathématiques
Optimiser une fonction
Manipuler les matrices
Les fonctions statistiques de base
Les loi de probabilités, ajustement et test
https://fr.wikibooks.org/wiki/Programmer_en_R 1/2
28/11/2021 00:43 Programmer en R — Wikilivres
Bibliographie
Emil Hvitfeldt and Julia Silge, Supervised Machine Learning for Text Analysis in R, 2020,
https://smltar.com/
Voir aussi
Découvrir Scilab
Introduction au logiciel Maxima
Ce wikilivre porte l'indice CDU

suivant :
6/68/681/681.3/681.3.0
Récupérée de « https://fr.wikibooks.org/w/index.php?title=Programmer_en_R&oldid=650597 »
La dernière modification de cette page a été faite le 5 décembre 2020 à 13:59.
Les textes sont disponibles sous licence Creative Commons attribution partage à l’identique ; d’autres termes
peuvent s’appliquer.
Voyez les termes d’utilisation pour plus de détails.
https://fr.wikibooks.org/wiki/Programmer_en_R 2/2
28/11/2021 00:44 Programmer en R/Faire ses premiers pas — Wikilivres
Cette section constitue une rapide introduction à R.
Manipuler des nombres

On peut facilement réaliser les opérations standards dans R.
> 1+1
[1] 2
> 2*3
[1] 6
> 2/3
[1] 0.6666667
> 2^3
[1] 8
Manipuler du texte
Pour différencier les chaînes de caractères (ie le texte) des nombres, il suffit d'utiliser les
guillemets.
> "ceci est une chaîne de caractère"
[1] "ceci est une chaîne de caractère"
Enregistrer des données

Pour assigner une valeur à un objet, on utilise l'opérateur <-
> x <- 5
On peut ensuite afficher la valeur :
> print(x)
[1] 5
On peut aussi utiliser cet objet dans d'autres calculs :
> x + 1
[1] 6
https://fr.wikibooks.org/wiki/Programmer_en_R/Faire_ses_premiers_pas 1/5
Vecteurs
Un vecteur est une suite de valeur de même type. Par exemple, on peut avoir un vecteur de
nombres ou un vecteur de chaînes de caractères.
La fonction c() permet de construire un vecteur.
> prix <- c(1.90, 3.50, 14.90)
> prix
[1] 1.9 3.5 14.9
> fruit <- c("pomme", "poire", "fraise")
> fruit
[1] "pomme" "poire" "fraise"
On peut accéder à un élément du vecteur en utilisant les crochets et le numéro de l'élément.
> fruit <- c("pomme", "poire", "fraise")
> fruit[1]
[1] "pomme"
> fruit[1:2]
[1] "pomme" "poire"
> fruit[1:3]
[1] "pomme" "poire" "fraise"
> fruit[c(1,3)]
[1] "pomme" "fraise"
Matrices
Une matrice est formée à partir d'un vecteur, en précisant le nombre de lignes et/ou de colonnes.
Par exemple :
> A <- matrix(c(1, 2, 3, 4, 5, 6), nrow=2)
> print(A)
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6
> B <- array(1:6, dim = c(3, 2))
> print(B)
[,1] [,2]
[1,] 1 4
[2,] 2 5
[3,] 3 6
On peut aussi assembler des vecteurs-ligne (row bind) :
> A <- rbind(c(1, 3, 5), c(2, 4, 6)); print(A)
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6
Les opérations algébriques élémentaires sont les suivantes :
> A %*% B # produit matriciel
[,1] [,2]
[1,] 22 49
[2,] 28 64
> aperm(A, c(2, 1)) # transposition
[,1] [,2]
[1,] 1 2
[2,] 3 4
[3,] 5 6
> A*A # produit terme à terme
[,1] [,2] [,3]
[1,] 1 9 25
[2,] 4 16 36
Tableaux de données
Souvent en statistiques, on manipule des données sous forme de tableaux. En R, les tableaux de
données sont appelés data.frame.
> table_fruits <- data.frame(
+ fruit = c("pomme", "poire", "fraise"),
+ prix = c(1.90, 3.50, 14.90)
+ )
>
> table_fruits
fruit prix
1 pomme 1.9
2 poire 3.5
3 fraise 14.9
Pour accéder à la colonne prix, on peut utiliser :
utiliser la syntaxe des crochets et indiquer le nom de la colonne après la virgule

utiliser la syntaxe des crochets et indiquer le numéro de la colonne après la virgule
appeler la colonne en utilisant la syntaxe nom_du_tableau$nom_de_la_variable
> table_fruits[,"prix"]
[1] 1.9 3.5 14.9
> table_fruits[,2]
[1] 1.9 3.5 14.9
> table_fruits$prix
[1] 1.9 3.5 14.9
Pour accéder à la deuxième ligne, on utilise la syntaxe des crochets :
table_fruits[2,]
> table_fruits[2,]
fruit prix
2 poire 3.5
Pour en savoir plus, sur la manière dont on manipule un tableau de données, on peut lire la section
Manipuler un tableau de données.
Obtenir de l'aide
On peut obtenir de l'aide sur une fonction avec la commande help("")
> help("abs")
> help("^")
ou bien avec le point d'interrogation
> ?abs
> ?"^"
Le point d'interrogation recherche dans toutes les librairies importées. Pour chercher dans toutes
les librairies installées sur le système, on utilise ??
>??select
Installer et charger une librairie

R contient de nombreuses librairies développées par la communauté. Pour installer une librairie,
on utilise la fonction install.packages() et pour la charger dans R, on utilise la fonction
library(). Par exemple, on peut installer et charger la librarie dplyr.
install.packages("dplyr")
library("dplyr")
L'opérateur tube
Traditionnellement, les arguments d'une fonction sont mis entre parenthèse après le nom de la
fonction et on peut composer les fonctions en imbriquant des fonctions dans des fonctions. Par
exemple :
> exp(5)
[1] 148.4132
> log(exp(5))
[1] 5
Lorsqu'on enchaîne de nombreuses fonctions, cette syntaxe peut poser des problèmes de lisibilité
du code. L'opérateur tube %>% (ou pipe) a été introduit par le développeur Stefan Milton Bache
dans la librairie magrittr. Cet opérateur est importé par défaut dans de nombreuses librairies
comme dplyr et permet de rendre le code plus lisible. Cet opérateur est très pratique lorsqu'on
enchaîne plusieurs fonctions à la suite [1] .
> 5 %>% exp()
[1] 148.4132
> 5 %>% exp() %>% log()
[1] 5
Notes et références
1. http://r4ds.had.co.nz/pipes.html
Voir aussi
anglais : R for cats (http://rforcats.net/) écrit par Scott Chamberlain
Récupérée de « https://fr.wikibooks.org/w/index.php?
title=Programmer_en_R/Faire_ses_premiers_pas&oldid=636955 »
La dernière modification de cette page a été faite le 20 avril 2020 à 13:50.
28/11/2021 00:44 Programmer en R/Installer R — Wikilivres
Sous Linux
R fait partie des distributions Debian et Ubuntu. Pour l'installer, il suffit d'utiliser la commande
apt-get :
$ sudo apt-get install r-base
Sous Windows
Pour installer R sous Windows, il suffit de télécharger le programme d'installation sur le site du
projet R [1] .
1. https://cran.r-project.org/bin/windows/base/
Récupérée de « https://fr.wikibooks.org/w/index.php?title=Programmer_en_R/Installer_R&oldid=636978 »
https://fr.wikibooks.org/wiki/Programmer_en_R/Installer_R 1/1
28/11/2021 00:45 Programmer en R/Choisir son environnement de travail — Wikilivres
Terminal
On peut lancer R dans un terminal et travailler directement en ligne de commande.
Console interactive de commande en langage R.
Radian
Radian permet d'avoir une interface améliorée dans le terminal. Le projet s'inspire de iPython [1] .
RStudio
RStudio est l'environnement de travail le plus couramment utilisé pour travailler avec R. RStudio
peut-être installé sur l'ordinateur local ou sur un serveur.
https://fr.wikibooks.org/wiki/Programmer_en_R/Choisir_son_environnement_de_travail 1/3
RStudio sous Ubuntu.
Jupyter Notebook
Jupyter Notebook est une interface utilisateur très couramment employée pour travailler avec
Python et Julia. Il est possible d'installer un noyau pour travailler avec R dans Jupyter Notebook.
Un notebook permet de combiner du texte et du code dans un même document.
Comme RStudio, Jupyter Notebook peut être installé localement ou sur un serveur.
Installation
Au préalable, il faut avoir installé Jupyter [2]
$ pip3 install jupyter
Après avoir installé Jupyter, il faut installer le noyau R [3] depuis un terminal R ouvert :
install.packages(c('repr', 'IRdisplay', 'crayon', 'pbdZMQ', 'devtools'))
devtools::install_github('IRkernel/IRkernel')
IRkernel::installspec() # to register the kernel in the current R

installation
1. https://github.com/randy3k/radian
2. http://jupyter.readthedocs.io/en/latest/install.html
3. https://github.com/IRkernel/IRkernel
title=Programmer_en_R/Choisir_son_environnement_de_travail&oldid=663032 »
La dernière modification de cette page a été faite le 6 septembre 2021 à 18:21.
Les textes sont disponibles sous licence Creative Commons attribution partage à l’identique ; d’autres termes peuvent
s’appliquer.
28/11/2021 00:45 Programmer en R/Installer des librairies — Wikilivres
Installer une librairie depuis le CRAN

La fonction install.packages() permet d'installer une librairie depuis le Comprehensive R
Archive Network.
install.packages("devtools")
Installer une librairie depuis Github

La fonction install_github() dans la librairie devtools permet d'installer une librairie depuis
Github.
library("devtools")
install_github("dgrtwo/broom")
Récupérée de « https://fr.wikibooks.org/w/index.php?title=Programmer_en_R/Installer_des_librairies&oldid=636976 »
https://fr.wikibooks.org/wiki/Programmer_en_R/Installer_des_librairies 1/1
28/11/2021 00:45 Programmer en R/Se documenter — Wikilivres
Aide
Le site RDocumentation.org permet de chercher facilement dans l'aide de toutes les librairies R
disponibles sur le CRAN et sur Github. Ce site permet souvent de trouver une fonction qui
correspond à ce qu'on cherche [1] .
Forums
Pour toutes les questions autour de la programmation R, le forum StackOverflow est très riche [2] .
Twitter
Il existe une importante communauté qui twitte autour de R avec le hashtag #rstats.
Ouvrages
L'ouvrage collectif Introduction à l'analyse de données avec R et RStudio, rédigé par des
démographes et des sociologues français, constitue une très bonne référence pour des utilisateurs
débutants avec un profil de sciences sociales [3] .
L'ouvrages de Garret Grolemund et Hadley Wickham R for Data Science constitue une bonne
référence pour un utilisateur de niveau intermédiaire [4] .
Blogosphère
Il existe une importante blogosphère francophone autour de R. Parmi eux, Arthur Charpentier
publie régulièrement des articles contenant du code R avec des applications en finances et en
assurance [5] , Baptiste Coulmont publie des articles avec des applications en sociologie [6] et
Christian Robert publie des articles autour des statistiques bayésiennes [7] .
Voir aussi
(anglais) R-project (http://www.r-project.org/), le site officiel de R
An Introduction to R (http://cran.r-project.org/doc/manuals/r-release/R-intro.html)
R Language Definition (http://cran.r-project.org/doc/manuals/r-release/R-lang.html)
(anglais) R Wiki (http://rwiki.sciviews.org/)
(anglais) R-bloggers - agrégateur de blogs dédiés à R (http://www.r-bloggers.com/)
Groupe ElementR : analyse spatiale et cartographie avec R (https://elementr.hypotheses.or
g/)
1. https://www.rdocumentation.org/
2. http://stackoverflow.com/questions/tagged/r
https://fr.wikibooks.org/wiki/Programmer_en_R/Se_documenter 1/2
28/11/2021 00:45 Programmer en R/Se documenter — Wikilivres
3. Manuel collectif d'analyse de données en sciences sociales (https://larmarange.github.io/analy

se-R/)
4. (en) Garrett Grolemund et Hadley Wickham, R for Data Science, O'Reilly, 2016, 1re éd. (lire en
ligne (http://r4ds.had.co.nz/index.html))
5. http://freakonometrics.hypotheses.org/tag/r
6. http://coulmont.com/blog/tag/R/
7. https://xianblog.wordpress.com/tag/r/
Récupérée de « https://fr.wikibooks.org/w/index.php?title=Programmer_en_R/Se_documenter&oldid=636975 »
https://fr.wikibooks.org/wiki/Programmer_en_R/Se_documenter 2/2
28/11/2021 00:46 Programmer en R/Manipuler les nombres — Wikilivres
En R, il y a deux types numériques principaux :
les entiers,
les nombres à virgule flottante.
Les deux types sont manipulés à travers les ensembles : vecteurs, matrices, ...
Vecteur de nombres
Un vecteur de nombre est déclaré en appelant la fonction c (Concatenate) qui crée un vecteur par
concaténation d'éléments de même type.
Exemple :
## Vecteur de nombres à virgule flottante :
> a = c(12,7,5.3,9.1,24)
> a
[1] 12.0 7.0 5.3 9.1 24.0
> typeof(a)
[1] "double"
Pour spécifier des entiers, il faut suffixer les nombres par la lettre L pour Long :
## Vecteur de nombres entiers :
> a = c(12L,7L,5L.3L,9L,24L)
> a
[1] 12 7 5 9 24
> typeof(a)
[1] "integer"
Séquence de nombres
Dans le cas d'une séquence continue d'entiers compris entre deux bornes, une autre manière de
générer un vecteur les contenant est d’utiliser l'opérateur deux-points : placés entre les bornes :
## Vecteur de tous les nombres entiers entre 1 et 10
> 1:10
[1] 1 2 3 4 5 6 7 8 9 10
La fonction seq permet de générer une séquence de nombres avec un pas différent, soit spécifié
explicitement, soit en spécifiant le nombre total de nombres dans la séquence.
Exemple :
https://fr.wikibooks.org/wiki/Programmer_en_R/Manipuler_les_nombres 1/3
# Séquence de nombre de 1 à 21 par incrément de 2
> seq(from = 1, to = 21, by = 2)
[1] 1 3 5 7 9 11 13 15 17 19 21
# Séquence de 15 nombres de 1 à 21 par incrément constant
> seq(0, 21, length.out = 15)
[1] 0.0 1.5 3.0 4.5 6.0 7.5 9.0 10.5 12.0 13.5 15.0 16.5 18.0 19.5
21.0
Répétition d'une séquence

La fonction rep permet de répéter une séquence un nombre spécifié de fois, de deux manières
différentes.
Répéter toute la séquence :
> rep(1:4, times = 2)
[1] 1 2 3 4 1 2 3 4
Répéter chaque élément :
> rep(1:4, each = 2)
[1] 1 1 2 2 3 3 4 4
Conversion
La conversion en un type numérique se fait à l'aide de 3 fonctions :
as.numeric(v)
Convertir en nombre (à virgule flottante),
as.double(v)
Convertir en nombre à virgule flottante,
as.integer(v)
Convertir en nombre entier.
Exemple :
## Vecteur de nombres entiers :
> a = c(12L,7L,5L.3L,9L,24L)
> as.double(a)
[1] 12.0 7.0 5.0 9.0 24.0
> b = c(12,7,5.3,9.1,24)
> as.integer(b)
[1] 12 7 5 9 24
title=Programmer_en_R/Manipuler_les_nombres&oldid=650602 »
28/11/2021 00:46 Programmer en R/Manipuler les vecteurs — Wikilivres
Notion de vecteur
Dans le chapitre précédent on a pu voir qu'un nombre possède deux types numeric et vector. En
réalité il s'agit d'un vecteur qui ne contient qu'un seul nombre.
> a = 2
> is (a)
[1] "numeric" "vector"
La notion de vecteur est essentielle. C'est cette structure de donnée qui est utilisée lorsque l'on
veut traiter une série de donnée.
Bien qu'étant essentiellement une série de valeurs, R fournit tout de même des opérateurs et
fonctions permettant de traiter les vecteurs comme en géométrie ou en algèbre (somme, produit
par un scalaire, produit scalaire entre deux vecteurs).
Initialisation d'un vecteur

La fonction c permet de créer un vecteur. Tous les éléments d'un vecteur doivent être du même
type.
> a = c(12,7,5.3,9.1,24)
> a
[1] 12.0 7.0 5.3 9.1 24.0
> is (a)
[1] "numeric" "vector"
> b = c("Vecteur", "de", "chaîne", "de", "caractère")
> b
[1] "Vecteur" "de" "chaîne" "de" "caractère"
> is (b)
[1] "character" "vector" "data.frameRowLabels"
> c = c("Dans", 1, "vecteur contenant", 1, "nombre tout est convertie en

chaîne de caractère")
> c
[1] "Dans"
[2] "1"
[3] "vecteur contenant"
[4] "1"
[5] "nombre tout est convertie en chaîne de caractère"
Les nombres [1], ..., [5] apparaissant ci-dessus sont les indices des différents éléments du
vecteur. Le premier indice d'un vecteur est 1.
Plusieurs fonctions permettent de créer des vecteurs :
https://fr.wikibooks.org/wiki/Programmer_en_R/Manipuler_les_vecteurs 1/5
Fonction Description Syntaxe
c (http://stat.ethz.ch/R-manual/
Crée un vecteur à partir des éléments
R-devel/library/base/html/c.htm c(..., recursive=FALSE)
donnés en paramètre.
l)
seq(from = 1, to = 1, by
seq (http://stat.ethz.ch/R-manu = ((to -
al/R-devel/library/base/html/se Crée une suite arithmétique. from)/(length.out - 1)),
q.html) length.out = NULL,

along.with = NULL, ...)
: (http://stat.ethz.ch/R-manual/ Crée une suite arithmétique de raison

R-devel/library/base/html/Colo 1. from:to est équilavent à seq from:to
n.html) (from, to)
rep (http://stat.ethz.ch/R-manu
al/R-devel/library/base/html/re Duplique la valeur de x rep(x, ...)
p.html)
> seq (1,13,1.2)
[1] 1.0 2.2 3.4 4.6 5.8 7.0 8.2 9.4 10.6 11.8 13.0
> 1:10
[1] 1 2 3 4 5 6 7 8 9 10
> rep (0,10)
[1] 0 0 0 0 0 0 0 0 0 0
Extraire ou assigner une composante

Pour avoir accès à la valeur du i-ème élément, on utilise la notation [i] ; si l'on veut les éléments i,
j et k, on utilise un vecteur d'indices [c(i, j, k)].
> x <- c(1:5, 10:15)
> print(x)
[1] 1 2 3 4 5 10 11 12 13 14 15
> x[6]
[1] 10
> x[4:7]
[1] 4 5 10 11
> x[c(1, 3, 6)]
[1] 1 3 10
On peut aussi utiliser un vecteur de booléens ; R extrait alors les éléments correspondant aux
valeurs vraies. Par exemple :
> x <- c(1:5, 10:15)
> indices = x > 5
> x[indices]
[1] 10 11 12 13 14 15
Arithmétique des vecteurs

Les opérations arithmétiques entre deux vecteurs de même dimension sont des opérations terme à
terme. Une opération arithmétique entre deux vecteurs de même dimension retourne un vecteur
dont les éléments correspondent à l'opération arithmétique effectuée pour l'indice correspondant
des vecteurs donnés en argument.
> a <- c(1, 6, 2, 4)
> b <- c(9, 2, 6, 1)
> a+b
[1] 10 8 8 5
> a/b
[1] 0.1111111 3.0000000 0.3333333 4.0000000
La somme de deux vecteurs correspond donc à la notion algébrique.
Si un vecteur est plus petit que l'autre, R répète les valeurs du plus petit vecteur jusqu'à générer un
vecteur de même taille que le plus grand. En particulier, si un des vecteurs est un scalaire, alors R
applique l'opération entre le scalaire et tous les éléments du vecteur
> a <- 1:10
> a+5
[1] 6 7 8 9 10 11 12 13 14 15
Pour déterminer les nombres impairs :
> a %% 2 == 1
[1] TRUE FALSE TRUE FALSE TRUE FALSE TRUE FALSE TRUE FALSE
Ainsi, l'opération multiplication d'un vecteur par un scalaire correspond à l'opération algébrique.
> v <- c(2, 3)
> 4*v
[1] 8 12
Opérations algébriques
L'opérateur %*% (pourcent-astérisque-pourcent) effectue un produit scalaire, en supposant la base
orthonormale :
> u <- c(1, 2)
> v <- c(3, -1)
> u%*%v
[,1]
[1,] 1
Notons que le résultat est une matrice d'une seule composante (un tableau d'une seule case). On
peut extraire le résultat en prenant l'élément (1, 1) de la matrice, ou bien en faisant la somme
cumulée de ce vecteur :
> a <- u%*%v
> is(a)
[1] "matrix" "array" "structure" "vector"
> a[1, 1]
[1] 1
> cumsum(a)
[1] 1
On peut ainsi calculer la norme du vecteur par
> sqrt(u%*%u)
[,1]
[1,] 2.236068
Vecteur comme suite de valeurs

Le vecteur peut aussi représenter une suite u1, u2, …, un. Le logiciel R fournit les fonctions :
min(), max() : donne la valeur respectivement minimale et maximale de la suite ;

cumsum() : effectue la somme cumulée du vecteur ; cela correspond à la somme de la
série ; cette fonction renvoie un vecteur de même taille que le vecteur initial, contenant
(u1, u1 + u2, …, ∑un) ;

cumprod() : effectue le produit cumulé du vecteur ; cette fonction renvoie un vecteur de
même taille que le vecteur initial, contenant
(u1, u1×u2, …, ∏un) ;

cummax(), cummin() : renvoie respectivement le maximum et le minimum cumulé ; le
résultat est un vecteur de même taille, l'élément i étant max{uj, j ∈ [1 ; i]} (resp. min{uj, j ∈ [1 ;
i]}).
title=Programmer_en_R/Manipuler_les_vecteurs&oldid=636972 »
28/11/2021 00:46 Programmer en R/Manipuler les chaînes de caractères — Wikilivres
La libraririe stringr permet de manipuler les chaînes de caractères.
Pré-requis
> library(stringr)
Nous prenons pour exemple le vecteur "banane", "fraise", "orange", "pomme".
> fruits <- c("banane", "fraise", "orange", "pomme")
> class(x = x)
[1] "character"
Mesurer la longueur d'une chaîne de caractère

La fonction str_length() permet de mesurer la longueur d'une chaîne de caractères :
> fruits %>% str_length()
[1] 6 6 6 5
Passer en majuscules, en minuscules ou en titres

str_to_upper() : permet de mettre toutes les lettres en majuscule
str_to_title() : passe les premières lettres de chaque mot en majuscule
str_to_lower() : passe toutes les lettres en minuscule
> fruits %>% str_to_upper()
[1] "BANANE" "FRAISE" "ORANGE" "POMME"
> fruits %>% str_to_title()
[1] "Banane" "Fraise" "Orange" "Pomme"
Coller des chaînes de caractères

Pour coller deux chaînes de caractères, on utilise la fonction str_c().
Par exemple, on peut coller le vecteur c("la", "la", "l'", "la") avec le vecteur fruits et les
séparer par un espace :
> str_c(c("la", "la", "l'", "la"), fruits, sep = " ")
[1] "la banane" "la fraise" "l' orange" "la pomme"
https://fr.wikibooks.org/wiki/Programmer_en_R/Manipuler_les_chaînes_de_caractères 1/2
28/11/2021 00:46 Programmer en R/Manipuler les chaînes de caractères — Wikilivres
Voir aussi
Stringr (http://stringr.tidyverse.org/)
title=Programmer_en_R/Manipuler_les_chaînes_de_caractères&oldid=636971 »
https://fr.wikibooks.org/wiki/Programmer_en_R/Manipuler_les_chaînes_de_caractères 2/2
28/11/2021 00:47 Programmer en R/Manipuler les facteurs — Wikilivres
En R, un facteur (ou factor) est un vecteur contenant uniquement certaines valeurs

prédéfinies [1] . Les valeurs pré-définies sont appelées des levels.
La librairie forcats contient un certain nombre de fonction permettant de travailler facilement

avec des facteurs.
Introduction
Dans cette section, on génère aléatoirement un vecteur pouvant prendre trois valeurs : "fraise",
"banane" ou "orange". On part du vecteur contenant les trois valeurs :
> c("orange", "banane", "fraise")
[1] "orange" "banane" "fraise"
On tire aléatoirement dans ce vecteur grâce à la fonction sample() avec l'option size=10 et
replace = TRUE (tirage avec remise.
> x <- sample(x = c("orange", "banane", "fraise"), size = 10, replace =

TRUE)
> x
[1] "banane" "banane" "orange" "banane" "orange" "fraise" "fraise"

"orange" "banane" "banane"
Pour le moment, le vecteur x est de classe chaîne de caractère :
> class(x)
[1] "character"
Comme il prend un nombre fini de valeurs, on pourrait aussi le définir comme un facteur :
> x <- factor(x = x)
> x
[1] banane banane orange banane orange fraise fraise orange banane banane
Levels: banane fraise orange
La fonction levels() permet d'obtenir la liste des valeurs :
> levels(x = x)
[1] "banane" "fraise" "orange"
https://fr.wikibooks.org/wiki/Programmer_en_R/Manipuler_les_facteurs 1/2
28/11/2021 00:47 Programmer en R/Manipuler les facteurs — Wikilivres
Tri à plat
La fonction fct_count() permet de réaliser un tri à plat :
> fct_count(x)
# A tibble: 3 × 2
f n
<fctr> <int>
1 banane 5
2 fraise 2
3 orange 3
1. http://adv-r.had.co.nz/Data-structures.html#vectors
Voir aussi
Forcats (http://forcats.tidyverse.org/) sur tidyverse.org
Facteurs et vecteurs labellisés (http://larmarange.github.io/analyse-R/facteurs-et-vecteurs-la
bellises.html)
title=Programmer_en_R/Manipuler_les_facteurs&oldid=636970 »
https://fr.wikibooks.org/wiki/Programmer_en_R/Manipuler_les_facteurs 2/2
28/11/2021 00:47 Programmer en R/Manipuler les dates et les heures — Wikilivres
La librairie lubridate définit un grand nombre de fonctions pour manipuler les dates et les
heures.
Pré-requis
install.packages(c("lubridate", "magrittr"))
library("lubridate")
library("magrittr")
Convertir les chaînes de caractères ou dates ou en

heures
Les dates sont souvent stockées comme des chaînes de caractère. Les fonctions ymd(), dmy() et
ydm() permettent de convertir les dates au format date.
> dmy("31 janvier 2016")
[1] "2016-01-31"
Extraire des informations d'une date

Pour toute date, on peut facilement extraire des éléments comme l'année, le mois, le jour de
l'année, le jour du mois, le jour de la semaine, etc.
> x <- dmy("31 octobre 2016")
> year(x) # année
[1] 2016
> month(x) # mois
[1] 10
> month(x, label = TRUE) # mois
[1] Oct
Levels: Jan < Feb < Mar < Apr < May < Jun < Jul < Aug < Sep < Oct < Nov <
Dec
> mday(x = x) # jour du mois
[1] 31
> yday(x) # jour de l'année
[1] 305
> wday(x) # jour de la semaine
[1] 2
> wday(x, label = TRUE) # jour de la semaine
[1] Mon
Levels: Sun < Mon < Tues < Wed < Thurs < Fri < Sat
https://fr.wikibooks.org/wiki/Programmer_en_R/Manipuler_les_dates_et_les_heures 1/3
Arrondir les dates

Les fonctions floor_date(), round_date() et ceiling_date() permettent d'arrondir les dates.
On peut choisir l'unité (semaine, mois, année).
> floor_date(x, unit = "week")
[1] "2016-10-30"
> ceiling_date(x, unit = "week")
[1] "2016-11-06 01:00:00 CET"
> round_date(x, unit = "week")
[1] "2016-10-30"
> floor_date(x, unit = "month")
[1] "2016-10-01"
> ceiling_date(x, unit = "month")
[1] "2016-11-01"
> round_date(x, unit = "month")
[1] "2016-11-01"
> floor_date(x, unit = "year")
[1] "2016-01-01"
> ceiling_date(x, unit = "year")
[1] "2017-01-01"
> round_date(x, unit = "year")
[1] "2017-01-01"
Travailler avec des durées, des périodes et des

intervalles de temps
lubridate définit trois concepts différents pour manipuler les durées, les périodes et les
intervalles de temps.
Les durées (duration) définissent des différences de temps en secondes.
> dseconds(10)
[1] "10s"
> dminutes(10)
[1] "600s (~10 minutes)"
> dhours(10)
[1] "36000s (~10 hours)"
Un intervalle de temps permet de définir un intervalle entre deux dates ou deux date-heure :
> interval(start = ymd("2014-07-03"), end = today())
[1] 2014-07-03 UTC--2016-11-30 UTC
On peut convertir un intervalle de temps en nombre de secondes, de minutes, de jours, de

semaines, de mois ou d'années à l'aide de la fonction time_length()
> time_length(interval(start = ymd("2014-07-03"), end = today()), unit =

"seconds")
[1] 76118400

"days")
[1] 881

"weeks")
[1] 125.8571

"months")
[1] 28.9

"years")
[1] 2.410959
Voir aussi
Vignette Lubridate (https://cran.r-
project.org/web/packages/lubridate/vignettes/lubridate.html), anglais
Dates and times (http://r4ds.had.co.nz/dates-and-times.html) dans l'ouvrage R for data-
science], anglais
title=Programmer_en_R/Manipuler_les_dates_et_les_heures&oldid=636969 »
28/11/2021 00:47 Programmer en R/Manipuler un tableau de données — Wikilivres
En R, les données tabulaires sont généralement modélisées dans des tableaux de données
(data.frame). Un tableau de données est une liste dont tous les éléments sont des vecteurs de
même taille.
La librairie tibble introduit une nouvelle classe pour les tableaux de données. Les tibbles se
comportent exactement comme les data.frame mais leurs options d'impression par défaut sont
différentes [1] .
Développée par Hadley Wickham, la librarie dplyr a pour objectif de définir une grammaire pour
la manipulation de données. Cette grammaire repose sur quelques verbes simples :
select() permet de sélectionner les colonnes d'un jeu de données ;

filter() permet de filtrer les lignes en fonction de conditions logiques (par exemple
sélectionner les lignes où telle variable est supérieure à telle valeur, etc) ;
rename() permet de renommer les variables ;
summarise() permet de résumer ou synthétiser un jeu de données ;
mutate() permet de définir de nouvelles variables ;
arrange() permet de trier le tableau de données.
La librairie dplyr contient aussi la fonction group_by() qui permet d'effectuer chaque opération
sur des sous-groupes du jeu de données.
La librairie tidyr permet de mettre en forme un jeu de données en passant notamment des
données dont les valeurs sont réparties sur plusieurs colonnes dans un format long de type clé-
valeur et inversement des données sous forme clé-valeur dans un format large [2] . La librarie tidyr
contient donc essentiellement deux fonctions :
la fonction gather pour passer en mode clé-valeur

la fonction spread pour passer en mode large
Pré-requis
Pour cette section, il faut avoir installé dplyr.
library(tibble)
library(tidyr)
library(dplyr)
Exemples
Dans cette section, nous prenons comme exemple le fichier des députés déposé par l'association
Wikimédia France sur la plateforme data.gouv.fr [3] . Ce fichier est au format CSV. Pour l'importer,
on utilise la fonction read_csv() de la librairie readr. Pour en savoir plus sur l'import des fichiers
CSV, on peut consulter la page Importer un fichier CSV.
https://fr.wikibooks.org/wiki/Programmer_en_R/Manipuler_un_tableau_de_données 1/9
library(readr)
table_deputes <- read_csv("data/deputes.csv")
Afficher un aperçu
La fonction glimpse() permet d'afficher un aperçu du tableau de données avec le nombre
d'observations, le nombre de variables, le nom, le type et les premières valeurs de chacune
des colonnes.
La fonction str() produit un résultat similaire
La fonction head() permet d'afficher les premières lignes d'un tableau de données
> table_deputes %>%
+ glimpse()
Observations: 575
Variables: 10
$ nom <chr> "François Fillon", "François de Rugy", "Hervé

Gaymard", "Aurélie Filipp...
$ genre <chr> "masculin", "masculin", "masculin", "féminin",

"féminin", "féminin", "m...
$ prenom <chr> "François", "François", "Hervé", "Aurélie",

"Delphine", "Marion", "Jacq...
$ nom_famille <chr> "Fillon", "de Rugy", "Gaymard", "Filippetti",

"Batho", "Maréchal-Le Pen...
$ date_naissance <dttm> 1954-03-04, 1973-12-06, 1960-05-31, 1973-06-17,

1973-03-23, 1989-12-10...
$ lieu_naissance <chr> "Le Mans", "Nantes", "Bourg-Saint-Maurice",

"Villerupt", "Paris", "Sain...
$ circonscription <chr> "deuxième circonscription de Paris", "première

circonscription de la Lo...
$ sycomore_id <int> 3009, 17282, 3322, 17302, 17264, 18477, 921, 17275,
476, 17280, 1300, 1...
$ wikidata <chr> "http://www.wikidata.org/entity/Q101410",

"http://www.wikidata.org/enti...
$ frwiki <chr>
"https://fr.wikipedia.org/wiki/Fran%C3%A7ois%20Fillon", "https://fr.wik...
Parcourir les données

Pour parcourir les données, on utilise la fonction View().
table_deputes %>% View()
Filtrer les lignes

La fonction filter() permet de filtrer la table en fonction d'une condition logique.
Par exemple, sur la table des députés, on peut filtrer la table pour ne garder que les députés de
genre féminin :
> table_deputes %>%
+ filter(genre == "féminin")
# A tibble: 150 × 10
nom genre prenom nom_famille

date_naissance
<chr> <chr> <chr> <chr>

<dttm>
1 Aurélie Filippetti féminin Aurélie Filippetti

1973-06-17
2 Delphine Batho féminin Delphine Batho

1973-03-23
3 Marion Maréchal-Le Pen féminin Marion Maréchal-Le Pen

1989-12-10
4 Michèle Delaunay féminin Michèle Delaunay

1947-01-08
5 Marie-George Buffet féminin Marie-George Buffet

1949-05-07
6 Valérie Boyer féminin Valérie Boyer

1962-06-11
7 Sylvia Pinel féminin Sylvia Pinel

1977-09-28
8 Marie-Arlette Carlotti féminin Marie-Arlette Carlotti

1952-01-21
9 Nathalie Kosciusko-Morizet féminin Nathalie Kosciusko-Morizet

1973-05-14
10 Cécile Duflot féminin Cécile Duflot

1975-04-01
# ... with 140 more rows, and 5 more variables: lieu_naissance <chr>,
circonscription <chr>,
# sycomore_id <int>, wikidata <chr>, frwiki <chr>
On peut aussi combiner plusieurs conditions. Dans l'exemple suivant, on filtre les députés de genre
féminin dont l'année de naissance est postérieure à 1976. On utilise la fonction year() de la
librairie lubridate() pour extraire l'année de la date de naissance.
library(lubridate)
> table_deputes %>%
+ filter(genre == "féminin", year(date_naissance) >= 1976)
# A tibble: 9 × 10
nom genre prenom nom_famille date_naissance

lieu_naissance
<chr> <chr> <chr> <chr> <dttm>

<chr>
1 Marion Maréchal-Le Pen féminin Marion Maréchal-Le Pen 1989-12-10

Saint-Germain-en-Laye
2 Sylvia Pinel féminin Sylvia Pinel 1977-09-28

L'Union
3 Seybah Dagoma féminin Seybah Dagoma 1978-06-09

Nantes
4 Stéphanie Pernod-Beaudon féminin Stéphanie Pernod-Beaudon 1978-10-13

Bourg-en-Bresse
5 Fanélie Carrey-Conte féminin Fanélie Carrey-Conte 1980-05-16

Bègles
6 Paola Zanetti féminin Paola Zanetti 1976-09-01

Créhange
7 Virginie Duby-Muller féminin Virginie Duby-Muller 1979-08-16

Bonneville
8 Marie Le Vern féminin Marie Le Vern 1983-01-11

Bois-Guillaume
9 Marine Brenier féminin Marine Brenier 1986-08-11

Nice
# ... with 4 more variables: circonscription <chr>, sycomore_id <int>,

wikidata <chr>, frwiki <chr>
La fonction slice() permet de filtrer un tableau de données en fonction des numéros de ligne.
> table_deputes %>% slice(1:10)
# A tibble: 10 × 10

lieu_naissance

<chr>
1 François Fillon masculin François Fillon 1954-03-04

Le Mans
2 François de Rugy masculin François de Rugy 1973-12-06

Nantes
3 Hervé Gaymard masculin Hervé Gaymard 1960-05-31

Bourg-Saint-Maurice
4 Aurélie Filippetti féminin Aurélie Filippetti 1973-06-17

Villerupt
5 Delphine Batho féminin Delphine Batho 1973-03-23

Paris

7 Jacques Bompard masculin Jacques Bompard 1943-02-24

Montpellier
8 Xavier Breton masculin Xavier Breton 1962-11-25

Darney
9 Christian Bataille masculin Christian Bataille 1946-05-13

Rieux-en-Cambrésis
10 Michèle Delaunay féminin Michèle Delaunay 1947-01-08

Clermont-Ferrand

Sélectionner des variables

La fonction select() permet de sélectionner les colonnes d'un tableau de données.
Par exemple, on peut sélectionner les colonnes "nom_famille", "prenom" et "genre" :
table_deputes %>%
select(nom_famille, prenom, genre)
On peut aussi utiliser des fonctions pour sélectionner rapidement plusieurs colonnes.
La fonction starts_with() sélectionne toutes les colonnes dont les noms commencent par
une chaîne de caractères donnée.
La fonction ends_with() sélectionne toutes les colonnes dont les noms se terminent par
une chaîne de caractères donnée.
La fonction contains() sélectionne toutes les colonnes dont les noms comprennent une
chaîne de caractère donnée.
> table_deputes %>%
+ select(starts_with("nom")) %>%
+ head(n = 2)
# A tibble: 2 × 2
nom nom_famille
<chr> <chr>
1 François Fillon Fillon
2 François de Rugy de Rugy
>
> table_deputes %>%
+ select(ends_with("naissance")) %>%
+ head(n = 2)
# A tibble: 2 × 2
date_naissance lieu_naissance
<dttm> <chr>
1 1954-03-04 Le Mans
2 1973-12-06 Nantes
>
> table_deputes %>%
+ select(contains("nom")) %>%
+ head(n = 2)
# A tibble: 2 × 3
nom prenom nom_famille
<chr> <chr> <chr>
1 François Fillon François Fillon
2 François de Rugy François de Rugy
Renommer les variables

La fonction names() permet d'afficher les noms de variables.
> table_deputes %>% names()
[1] "nom" "genre" "prenom" "nom_famille"

"date_naissance"
[6] "lieu_naissance" "circonscription" "sycomore_id" "wikidata"

"frwiki"
La fonction rename() permet de renommer certaines variables d'un tableau de données.

Par
exemple, on peut renommer la variable frwiki en frwikipedia.
> table_deputes %>%
+ rename(frwikipedia = frwiki) %>%
+ names()
[1] "nom" "genre" "prenom" "nom_famille"

"date_naissance"
[6] "lieu_naissance" "circonscription" "sycomore_id" "wikidata"

"frwikipedia"
Trier le tableau de données

La fonction arrange() permet de trier le tableau de données en fonction des valeurs d'une ou
plusieurs variables.
Par exemple, on peut trier le jeu de données des députés en fonction de la date
de naissance des députés :
> table_deputes %>%
+ arrange(date_naissance) %>%
+ head()
# A tibble: 6 × 10

lieu_naissance

<chr>
1 François Scellier masculin François Scellier 1936-05-07

Amiens
2 Alfred Marie-Jeanne masculin Alfred Marie-Jeanne 1936-11-15

Rivière-Pilote
3 Lucien Degauchy masculin Lucien Degauchy 1937-06-11

Hautefontaine
4 Bernard Brochand masculin Bernard Brochand 1938-06-05

Nice
5 Jean-Claude Mathis masculin Jean-Claude Mathis 1939-08-15

Bouzonville
6 Jean-Michel Couve masculin Jean-Michel Couve 1940-01-03

Le Muy

Par défaut, la fonction arrange() trie les valeurs par ordre ascendant. Pour trier les valeurs par
ordre descendant, on peut combiner avec la fonction desc().
> table_deputes %>%
+ arrange(desc(date_naissance)) %>%
+ head()
# A tibble: 6 × 10

lieu_naissance

<chr>

2 Marine Brenier féminin Marine Brenier 1986-08-11

Nice
3 Julien Dive masculin Julien Dive 1985-05-21

Saint-Quentin
4 Marie Le Vern féminin Marie Le Vern 1983-01-11

Bois-Guillaume
5 Laurent Marcangeli masculin Laurent Marcangeli 1980-12-10

Ajaccio
6 Fanélie Carrey-Conte féminin Fanélie Carrey-Conte 1980-05-16

Bègles

Définir de nouvelles variables

La fonction mutate() permet de définir de nouvelles variables.
Par exemple, sur la table des députés, on a la date de naissance. On peut calculer donc calculer
l'âge des députés. Pour calculer l'âge, on utilise plusieurs fonction de la librairie lubridate. La
fonction today() donne la date d'aujourd'hui. La fonction interval() permet de définir un
intervalle de temps entre deux dates. Enfin, la fonction time_length() permet de convertir un
intervalle de temps en un nombre dans une unité donnée. Ici, on choisit d'exprimer l'âge en année.
Dans l'exemple, on combine aussi avec les fonctions select() et glimpse() pour afficher un
aperçu du nouveau jeu de données avec la nouvelle variable.
> library(lubridate)
> table_deputes %>%
+ mutate(
+ age = time_length(
+ interval(
+ start = date_naissance,
+ end = today()
+ ),
+ unit = "year"
+ )
+ ) %>%
+ select(nom, date_naissance, age) %>%

+ glimpse()
Observations: 575
Variables: 3

Gaymard", "Aurélie Filippetti", "De...

1973-03-23, 1989-12-10, 1943-02-...
$ age <dbl> 62.74247, 42.98361, 56.50137, 43.45479, 43.69041,

26.97268, 73.76503, 54.01370, 7..
Synthétiser un tableau de données

La fonction summarise() permet de synthétiser un jeu de données.
On peut par exemple reprendre l'exemple précédent et calculer l'âge moyen des députés. Pour cela,
il suffit de définir la variable age = mean(age) dans la fonction summarise().
> table_deputes %>%
+ mutate(
+ interval(
+ end = today()
+ ),
+ unit = "year"
+ )
+ ) %>%
+ summarise(age = mean(age))
# A tibble: 1 × 1
age
<dbl>
1 58.80746
On peut aussi calculer d'autres indicateurs comme l'écart-type, le minimum et le maximum :
> table_deputes %>%
+ mutate(
+ interval(
+ end = today()
+ ),
+ unit = "year"
+ )
+ ) %>%
+ summarise(
+ age_moyen = mean(age),
+ age_median = median(age),
+ ecarttype_age = sd(age),
+ min_age = min(age),
+ max_age = max(age)
+ )
# A tibble: 1 × 5
age_moyen age_median ecarttype_age min_age max_age
<dbl> <dbl> <dbl> <dbl> <dbl>
1 58.80746 59.48219 10.10712 26.97268 80.56712
Comprendre les opérations par sous-groupe

La librairie dplyr permet de définir des opérations sur des sous-groupes.
La fonction group_by() permet de définir les sous-groupes et la fonction ungroup() de revenir à un

tableau de données non groupé.
La fonction group_by() peut être combiné avec mutate() et summarise().
Voir aussi
anglais : Introduction to dplyr (https://cran.rstudio.com/web/packages/dplyr/vignettes/introduc
tion.html) par Hadley Wickham]
anglais : Data transformation (http://r4ds.had.co.nz/transform.html) dans l'ouvrage R for
Data Science de Garrett Grolemund et Hadley Wickham
Listes et tableaux de données (http://larmarange.github.io/analyse-R/listes-et-tableaux-de-do
nnes.html#tableaux-de-donnees) sur le site Introduction à l'analyse d'enquêtes avec R et
RStudio
anglais : Tibbles (http://r4ds.had.co.nz/tibbles.html) dans l'ouvrage R for Data Science de
Garrett Grolemund et Hadley Wickham
1. http://r4ds.had.co.nz/tibbles.html#tibbles-vs.data.frame
2. http://vita.had.co.nz/papers/tidy-data.html
3. http://www.data.gouv.fr/fr/datasets/listes-de-personnalites-issues-de-wikidata-1/
title=Programmer_en_R/Manipuler_un_tableau_de_données&oldid=638283 »
28/11/2021 00:48 Programmer en R/Manipuler une liste — Wikilivres
À la différences des vecteurs, les listes peuvent contenir des objets de natures différentes.
Une liste
peut combiner des vecteurs, des scalaires, des tableaux de données, etc.
Pré-requis
Dans cette section, nous prenons comme exemple le fichier JSON correspondant à l'élément
Wikidata Paris.
Ce fichier peut être importé sous forme de liste dans R grâce à la fonction
fromJSON().
library(jsonlite)
q90 <- fromJSON(txt =

"https://www.wikidata.org/wiki/Special:EntityData/Q90.json")
Parcourir une liste

La fonction jsonedit() de la librairie listviewer permet de visualiser et éditer une liste de manière
interactive.
library(listviewer)
jsonedit(q90)
Explorer la structure d'une liste

La fonction str() permet d'explorer la structure d'une liste.
> str(object = q90, max.level = 3)
List of 1
$ entities:List of 1
..$ Q90:List of 12
.. ..$ pageid : int 221
.. ..$ ns : int 0
.. ..$ title : chr "Q90"
.. ..$ lastrevid : int 396996043
.. ..$ modified : chr "2016-10-27T20:49:08Z"
.. ..$ type : chr "item"
.. ..$ id : chr "Q90"
.. ..$ labels :List of 259
.. .. .. [list output truncated]
.. ..$ descriptions:List of 55
.. ..$ aliases :List of 28
.. ..$ claims :List of 84
.. ..$ sitelinks :List of 294
.. .. .. [list output truncated]
https://fr.wikibooks.org/wiki/Programmer_en_R/Manipuler_une_liste 1/2
28/11/2021 00:48 Programmer en R/Manipuler une liste — Wikilivres
Voir aussi
Recursive lists (http://r4ds.had.co.nz/vectors.html#lists) dans R for data-science (anglais)
Simplifying data from a list of GitHub users (https://jennybc.github.io/purrr-tutorial/index.html)
Récupérée de « https://fr.wikibooks.org/w/index.php?title=Programmer_en_R/Manipuler_une_liste&oldid=636966 »
https://fr.wikibooks.org/wiki/Programmer_en_R/Manipuler_une_liste 2/2
28/11/2021 00:48 Programmer en R/Importer un fichier CSV — Wikilivres
Un fichier CSV est un fichier texte qui contient des données. En général, les valeurs sont séparées
par des virgules. Néanmoins, on trouve aussi souvent des valeurs séparées par des points virgules
(;) et il arrive que l'on trouve de nombreux autres séparateurs comme des pipes (|) ou même des
croisillons (#).
Dans la version basique de R, les fichiers CSV peuvent être importés avec les fonctions
read.csv(), read.csv2() et read.table().
La librairie readr développée par Hadley Wickham définit les fonctions read_csv(),
read_csv2() et read_delim() qui ont de meilleures performances et de meilleurs paramètres par
défaut que les fonctions standards.
Il existe aussi d'autre possibilité avec la librairie rio et la fonction fread() de la librairie
data.table.
Pré-requis
install.packages(c("readr", "dplyr"))
library(dplyr)
library(readr)
Importer un fichier CSV

Nous proposons de prendre comme exemple le fichier des députés postés par l'association
Wikimédia France sur DataGouv [1] .
La fonction read_csv() issue de la librairie readr permet de lire un fichier csv.

La fonction glimpse() de la librairie dplyr permet d'avoir un aperçu de la table obtenue.
> library(readr)
> library(dplyr)
> read_csv(file = "data/deputes.csv") %>%
+ glimpse()
Observations: 575
Variables: 10
$ nom (chr) "François Fillon", "François de Rugy", "Hervé

Gaymard", "Aurélie Filippetti"...
$ genre (chr) "masculin", "masculin", "masculin", "féminin",

"féminin", "féminin", "mascul...
$ prenom (chr) "François", "François", "Hervé", "Aurélie",

"Delphine", "Marion", "Jacques",...
$ nom_famille (chr) "Fillon", "de Rugy", "Gaymard", "Filippetti",

"Batho", "Maréchal-Le Pen", "B...
$ date_naissance (time) 1954-03-04, 1973-12-06, 1960-05-31, 1973-06-17,

1973-03-23, 1989-12-10, 194...
https://fr.wikibooks.org/wiki/Programmer_en_R/Importer_un_fichier_CSV 1/3
$ lieu_naissance (chr) "Le Mans", "Nantes", "Bourg-Saint-Maurice",

"Villerupt", "Paris", "Saint-Ger...
$ circonscription (chr) "deuxième circonscription de Paris", "première

circonscription de la Loire-A...
$ sycomore_id (int) 3009, 17282, 3322, 17302, 17264, 18477, 921, 17275,
476, 17280, 1300, 17274,...
$ wikidata (chr) "http://www.wikidata.org/entity/Q101410",

"http://www.wikidata.org/entity/Q1...
$ frwiki (chr)
"https://fr.wikipedia.org/wiki/Fran%C3%A7ois%20Fillon",
"https://fr.wikipedi...
La fonction read_csv() essaie de deviner le type de chaque variable. On peut aussi indiquer à la
fonction le type de chaque variable à l'aide de l'argument col_types. Les types doivent être
spécifiés dans la fonction cols() :
col_character() pour les chaînes de caractères

col_integer() pour les entiers
col_double() pour les nombres doubles
col_number() pour les nombres
col_factor() pour les facteurs
col_date() pour les dates
col_datetime() pour les dates heures
col_logical() pour les booléens
> read_csv(file = "data/deputes.csv",
+ col_types = cols(
+ nom = col_character(),
+ genre = col_character(),
+ prenom = col_character(),
+ date_naissance = col_datetime(),
+ lieu_naissance = col_character(),
+ circonscription = col_character(),
+ sycomore_id = col_character(),
+ wikidata = col_character(),
+ frwiki = col_character()
+ )
+ ) %>%
+ glimpse()
Observations: 575
Variables: 10

Gaymard", "Aurélie Filipp...
$ genre <chr> "masculin", "masculin", "masculin", "féminin",

"féminin", "féminin", "m...
$ prenom <chr> "François", "François", "Hervé", "Aurélie",

"Delphine", "Marion", "Jacq...
$ nom_famille <chr> "Fillon", "de Rugy", "Gaymard", "Filippetti",

"Batho", "Maréchal-Le Pen...

1973-03-23, 1989-12-10...
$ lieu_naissance <chr> "Le Mans", "Nantes", "Bourg-Saint-Maurice",

"Villerupt", "Paris", "Sain...
$ circonscription <chr> "deuxième circonscription de Paris", "première

circonscription de la Lo...
$ sycomore_id <chr> "3009", "17282", "3322", "17302", "17264", "18477",

"921", "17275", "47...
$ wikidata <chr> "http://www.wikidata.org/entity/Q101410",

"http://www.wikidata.org/enti...
$ frwiki <chr>
"https://fr.wikipedia.org/wiki/Fran%C3%A7ois%20Fillon", "https://fr.wik...
1. http://www.data.gouv.fr/fr/datasets/listes-de-personnalites-issues-de-wikidata-1/
Voir aussi
anglais : readr (http://readr.tidyverse.org/) sur tidyverse.org
anglais : data-import (http://r4ds.had.co.nz/data-import.html) dans le livre R for Data Science
de Garrett Grolemund et Hadley Wickham
Importer un fichier texte (http://larmarange.github.io/analyse-R/import-de-donnees.html#impo
rter-des-fichiers-texte) dans Introduction à l’analyse d’enquêtes avec R et RStudio
title=Programmer_en_R/Importer_un_fichier_CSV&oldid=647817 »
La dernière modification de cette page a été faite le 14 octobre 2020 à 22:40.
28/11/2021 00:48 Programmer en R/Résoudre les problèmes d'encodage des caractères — Wikilivres
L'import de fichiers CSV et des fichiers texte en général peut poser des problèmes d'encodage de
caractères. Dans cette section, nous passons en revue des méthodes pour détecter l'encodage d'un
fichier et convertir le fichier avant de l'importer dans R. Ces méthodes fonctionnent sous Mac OS
X et Linux.
Détecter l'encodage
Dans cette section, nous prenons pour exemple la liste des départements 2016 publiées par
l'Insee [1] .
Détecter l'encodage avec la commande file
Pour les utilisateurs de Mac OS X et Linux, nous recommandons d'ouvrir une fenêtre d'un
Terminal, d'aller dans le dossier correspondant (avec la commande cd) et d'utiliser la commande
file -i
$ cd ~/Documents/monprojet/data/
$ file -i depts2016.txt
depts2016.txt: regular file
Dans certains cas, cette commmande permet de connaître l'encodage des caractères. Dans ce cas
précis, nous n'avons pas d'information sur l'encodage des caractères dans ce fichier. Nous allons
utiliser la commande chardetect.
Détecter l'encodage avec la commande chardetect
Pour installer chardetect, il suffit d'utiliser la commmande pip install dans un terminal :
$ pip install chardet
Pour détecter l'encodage, on tape simplement chardetect suivi du nom du fichier :
$ chardetect depts2016.txt
depts2016.txt: windows-1252 with confidence 0.73
La commande nous indique que le fichier depts2016.txt est probablement encodé en windows-
1252.
Convertir l'encodage d'un fichier
https://fr.wikibooks.org/wiki/Programmer_en_R/Résoudre_les_problèmes_d%27encodage_des_caractères 1/2
28/11/2021 00:48 Programmer en R/Résoudre les problèmes d'encodage des caractères — Wikilivres
Pour convertir le fichier en encodage utf-8 (l'encodage couramment utilisé sur Linux et Mac OS X),
on utilise la commande iconv. iconv trois paramètres : l'encodage d'origine (-f pour from),
l'encodage de destination (-t pour to) et le nom du fichier :
$ iconv -f windows-1252 -t utf-8 depts2016.txt
REGION DEP CHEFLIEU TNCC NCC NCCENR
84 01 01053 5 AIN Ain
32 02 02408 5 AISNE Aisne
84 03 03190 5 ALLIER Allier
93 04 04070 4 ALPES-DE-HAUTE-PROVENCE Alpes-de-Haute-Provence
93 05 05061 4 HAUTES-ALPES Hautes-Alpes
93 06 06088 4 ALPES-MARITIMES Alpes-Maritimes
84 07 07186 5 ARDECHE Ardèche
On voit que cette fois-ci, les accents sont correctement affichés.
Pour enregistrer le résultat, on peut imprimer le résultat de cette commande dans un nouveau
fichier texte en indiquant tout simplement le nom du fichier de destination après un chevron > :
$ iconv -f windows-1252 -t utf-8 depts2016.txt > depts2016_utf8.txt
1. http://www.insee.fr/fr/methodes/nomenclatures/cog/telechargement/2016/txt/depts2016.txt
Voir aussi
iconv (https://doc.ubuntu-fr.org/iconv) sur la documentation francophone de la distribution
Ubuntu
tutoriel encodage des caractères (https://doc.ubuntu-fr.org/tutoriel/encodage_caracteres) sur
la documentation francophone de la distribution Ubuntu
title=Programmer_en_R/Résoudre_les_problèmes_d%27encodage_des_caractères&oldid=636960 »
https://fr.wikibooks.org/wiki/Programmer_en_R/Résoudre_les_problèmes_d%27encodage_des_caractères 2/2
28/11/2021 00:48 Programmer en R/Importer un fichier TSV — Wikilivres
Comme les fichiers CSV, les fichiers TSV sont des fichiers textes dans lesquelles les valeurs sont
séparées par des tabulations.
La fonction read_tsv() dans la librairie readr permet de les importer de manière efficace.
Par exemple, la liste des départements publiées sur le site de l'Insee est disponible au format
TSV [1] . Après avoir converti le fichier en encodage UTF-8 (voir le chapitre Résoudre les problèmes
d'encodage des caractères), on peut importer le fichier dans R avec la commande suivante :
> table_departements <- read_tsv(file = "data/depts2016_utf8.txt")
> table_departements %>% glimpse()
Observations: 101
Variables: 6
$ REGION <chr> "84", "32", "84", "93", "93", "93", "84", "44", "76",
"44", "76", "76", "93", ...
$ DEP <chr> "01", "02", "03", "04", "05", "06", "07", "08", "09",
"10", "11", "12", "13", ...
$ CHEFLIEU <chr> "01053", "02408", "03190", "04070", "05061", "06088",

"07186", "08105", "09122...
$ TNCC <int> 5, 5, 5, 4, 4, 4, 5, 4, 5, 5, 5, 5, 4, 2, 2, 3, 3, 2, 3,
3, 3, 3, 4, 3, 3, 2, ...
$ NCC <chr> "AIN", "AISNE", "ALLIER", "ALPES-DE-HAUTE-PROVENCE",

"HAUTES-ALPES", "ALPES-MA...
$ NCCENR <chr> "Ain", "Aisne", "Allier", "Alpes-de-Haute-Provence",

"Hautes-Alpes", "Alpes-Ma...table_
1. http://www.insee.fr/fr/methodes/nomenclatures/cog/telechargement/2016/txt/depts2016.txt
title=Programmer_en_R/Importer_un_fichier_TSV&oldid=636958 »
https://fr.wikibooks.org/wiki/Programmer_en_R/Importer_un_fichier_TSV 1/1
28/11/2021 00:49 Programmer en R/Importer un fichier texte à largeur fixe — Wikilivres
Exemple
On prend pour example le fichier FANTOIR sur data.gouv.fr [1] .
$ wget https://www.data.gouv.fr/fr/datasets/r/008e7b8f-f52c-4dc6-89ca-
3bed2b103746
$ mv 008e7b8f-f52c-4dc6-89ca-3bed2b103746 fantoir.zip
$ unzip fantoir.zip
Lire le fichier
On peut le lire facilement avec R et la librairie `readr` :
http://readr.tidyverse.org/reference/read_fwf.html
La fonction `fwf_empty()` détecte automatiquement la largeur des colonnes

La fonction `read_fwf()` permet de lire le fichier.
L'option n_max permet de ne lire que les 1000 premières lignes. C'est utile pour faire des
tests.
library(readr)
table_fantoir <- read_fwf(file="FANTOIR1017", fwf_empty("FANTOIR1017"),

n_max = 100)
Pour avoir un aperçu des données, on peut utiliser la fonction `glimpse()` de `dplyr`
library(dplyr)
table_fantoir %>% glimpse()
1. https://gist.github.com/pachevalier/d3fbf7c0bf01a71a36bd2d7de40c141c
title=Programmer_en_R/Importer_un_fichier_texte_à_largeur_fixe&oldid=636957 »
https://fr.wikibooks.org/wiki/Programmer_en_R/Importer_un_fichier_texte_à_largeur_fixe 1/2
28/11/2021 00:49 Programmer en R/Importer un fichier texte à largeur fixe — Wikilivres
https://fr.wikibooks.org/wiki/Programmer_en_R/Importer_un_fichier_texte_à_largeur_fixe 2/2
28/11/2021 00:50 Programmer en R/Importer des données depuis un tableur — Wikilivres
Pour importer des données depuis un tableur Excel, on peut utiliser la librairie readxl développée
par Hadley Wickham.
Import des données depuis un tableur Excel

Nous proposons un exemple à partir des données de la liste des fondations reconnues d'utilité
publiques diffusée par le ministère de l'Intérieur sur la plateforme Data.Gouv [1] .
On peut tout d'abord faire la liste des feuilles (ou onglets) du tableur excel avec la fonction
excel_sheets() :
library(readxl)
excel_sheets(path = "data/frup1606.xlsx")
On peut ensuite importer la première feuille avec la fonction read_excel(). La fonction glimpse(),
issue de la librairie dplyr, permet d'avoir un aperçu des données.
> read_excel(
+ path = "data/frup1606.xlsx",
+ sheet = "FRUP1306"
+ ) %>%
+ glimpse()
Observations: 65,534
Variables: 13
$ Code (chr) "01.020.0015", "02.020.0011", "02.020.0157",

"03.020.0005", "03.020.0...
$ Code (terminaison) (dbl) 15, 11, 157, 5, 142, 504, 384, 26, 13, 114,
147, 178, 245, 267, 287, ...
$ Nom (chr) "PIERRE VEROTS", "ORPHELINS DE BLERANCOURT",

"SAVART", "MAISON SAINT ...
$ Début du nom (chr) "FONDATION", "HOSPICE D'", "FONDATION", NA,

"FONDATION", "FONDATION",...
$ Objet (chr) "Mener en France une politique

d'information, de gestion, de conserva...
$ Date de reconnaissance (chr) "30846", "22/10/1666", "25/01/1895",
"12/02/1883", "11903", "38330", ...
$ Dernière modif statuts (time) NA, 1958-04-12, NA, 1972-04-28, NA, NA, NA,
2008-01-29, 2016-04-15, ...
$ Catégorie (chr) "24000 environnement", "18000 services

medico-sociaux", "18000 servic...
$ Adresse (chr) "SIEGE", "SIEGE", "SIEGE", "SIEGE", "SIEGE",

"SIEGE", "SIEGE", "SIEGE...
$ Adresse.Adr1 (chr) "Domaine de PRAILLEBARD", "2, rue Bernard

Potier", "Rue du Chamiteau"...
$ Adresse.Adr2 (chr) NA, NA, "BP 6", NA, NA, NA, NA, NA, NA, NA,
"4, avenue Pauliani", NA,...
https://fr.wikibooks.org/wiki/Programmer_en_R/Importer_des_données_depuis_un_tableur 1/2
28/11/2021 00:50 Programmer en R/Importer des données depuis un tableur — Wikilivres
$ Code Postal (dbl) 1390, 2300, 2830, 3600, 3200, 3200, 4100,
5107, 6200, 6000, 6046, 600...
$ Ville (chr) "SAINT-JEAN-DE-THURIGNEUX", "BLERANCOURT",

"SAINT-MICHEL", "COMMENTRY...
On peut aussi enregistrer les données dans un objet pour les réutiliser par la suite :
df_frup <- read_excel(
path = "data/frup1606.xlsx",
sheet = "FRUP1306"
1. http://www.data.gouv.fr/fr/datasets/frup-30-juin-2016/
Voir aussi
Import des données Excel (http://larmarange.github.io/analyse-R/import-de-donnees.html#ex
cel) dans Introduction à l’analyse d’enquêtes avec R et RStudio
title=Programmer_en_R/Importer_des_données_depuis_un_tableur&oldid=636954 »
https://fr.wikibooks.org/wiki/Programmer_en_R/Importer_des_données_depuis_un_tableur 2/2
28/11/2021 00:50 Programmer en R/Import un fichier JSON — Wikilivres
La fonction fromJSON() de la librairie jsonlite.
Chaque élément de Wikidata peut être exporté au format JSON. Par exemple, l'entité q90 (ie
Paris), accessible à l'URL https://www.wikidata.org/wiki/Q90, peut être exportée au format
JSON à l'url https://www.wikidata.org/wiki/Special:EntityData/Q90.json
library(jsonlite)
q90 <- fromJSON(txt =

"https://www.wikidata.org/wiki/Special:EntityData/Q90.json")
En général, les fichiers JSON peuvent être manipulés en R sous forme de liste.
title=Programmer_en_R/Import_un_fichier_JSON&oldid=636956 »
https://fr.wikibooks.org/wiki/Programmer_en_R/Import_un_fichier_JSON 1/1
28/11/2021 00:50 Programmer en R/Extraire des données d'une page web — Wikilivres
Les fonctions read_html et read_xml permettent de récupérer et interpréter un contenu au

format HTML ou XML, respectivement.
Syntaxe
read_xml(x, encoding = "", ..., as_html = FALSE, options = "NOBLANKS")
read_html(x, encoding = "", ..., options = c("RECOVER", "NOERROR",

"NOBLANKS"))
Les paramètres sont les suivants :
x
Plusieurs types possibles :
Une chaîne de caractère représentant soit l'URL, soit le contenu lui-même,
Une connexion ouverte, auquel cas tout le contenu est lu dans un vecteur avant
interprétation.
Si un chemin local se termine par une des extensions .gz, .bz2, .xz, .zip, le fichier est
automatiquement décompressé.
encoding
Encodage par défaut. S'il n'est pas spécifié, la fonction détecte les encodages UTF-8 ou
UTF-16.
as_html
Booléen indiquant d'interpréter le contenu au format HTML plutôt que XML.
options
Série d'options d'interprétation :
RECOVER : Récupération en cas d'erreur,
NOENT : Substituer les entités (& " ...),
DTDLOAD : Charger les DTD externes,
DTDATTR : Attributs DTD par défaut,
DTDVALID : Valider la syntaxe du contenu avec la DTD,
NOERROR : Supprimer les rapports d'erreur,
NOWARNING : Supprimer les rapports d'avertissement,
PEDANTIC : Vérification moins stricte,
NOBLANKS : Enlever les nœuds vides,
SAX1 : Utiliser l'interface SAX1 en interne,
XINCLUDE : Implémenter la substitution XInclude
NONET : Empêcher la connexion réseau (n'autorise qu'un chemin local),
NODICT : Ne pas réutiliser le dictionnaire de contexte,
NSCLEAN : Enlever les déclarations redondantes d'espaces de noms,
NOCDATA : Fusionner les CDATA comme nœuds de texte,
NOXINCNODE : Ne pas générer de nœuds XINCLUDE START/END,
COMPACT : Compacter les nœuds textes de petite taille ; modifications de
l'arborescence non autorisées par la suite, sinon un plantage est possible,
https://fr.wikibooks.org/wiki/Programmer_en_R/Extraire_des_données_d%27une_page_web 1/2
28/11/2021 00:50 Programmer en R/Extraire des données d'une page web — Wikilivres
OLD10 : Interpréter en utilisant XML-1.0 avant la mise à jour 5,

NOBASEFIX : Ne pas réparer les URIs de base (xml:base) XINCLUDE,
HUGE : Relâcher les contraintes de l'interpréteur,
OLDSAX : Utiliser l'interface SAX2 avant 2.7.0 en interne,
IGNORE_ENC : Ignore les indications d'encodage du document,
BIG_LINES : Stocker les grands nombres de lignes dans un champ texte PSVI (Post-
Schema-Validation Infoset).
Exemple
L'exemple suivant récupère le contenue d'une page HTML, en passant l'URL et l'encodage par
défaut à la fonction read_html :
wikibooks <- read_html("https://fr.wikibooks.org/wiki/Accueil", encoding =

"UTF-8")
Documentation
https://www.rdocumentation.org/packages/xml2/versions/1.3.2/topics/read_xml
title=Programmer_en_R/Extraire_des_données_d%27une_page_web&oldid=650559 »
https://fr.wikibooks.org/wiki/Programmer_en_R/Extraire_des_données_d%27une_page_web 2/2
28/11/2021 00:50 Programmer en R/Comprendre la grammaire des graphiques — Wikilivres
En R, il existe un système de graphique standard autour de la fonction plot() et la bibliothèque

("librairie" - library) ggplot2. Cette bibliothèque ggplot2 repose sur les principes de la
grammaire des graphiques [1] . L'idée principale est de concevoir un graphique comme une
succession de couches (layer). Chaque couche définit une correspondance entre certaines variables
ou leur transformation statistique et les attributs esthétiques (position dans l'espace, couleur,
épaisseur, etc) de formes géométriques définies (points, barres, lignes, tuiles, etc).
En pratique, il faut créer le graphique avec la fonction ggplot().
Ensuite définir les différentes couches avec les fonctions geom_ (geom_point(), geom_bar,
geom_line(), etc) ou stat_ (stat_density(), stat_count(), etc). Pour chacune de ses
fonctions, l'argument mapping et la fonction aes() permettent de définir la correspondance
entre des variables et les attributs esthétiques.
Puis spécifier les échelles avec les fonctions scale_.
le contexte (titre, sous-titre, caption, etc) avec la fonction labs().
L'utilisateur peut choisir un thème choisi à partir d'une liste de thèmes prédéfinis
(theme_tufte(), theme_stata(), etc) ou avec la fonction theme().
Il est aussi possible de réaliser le graphe sur des sous-échantillons du jeu de données avec les
fonctions facet_().
Particularité de la grammaire des graphiques, l'opérateur "pipe" est +. La bibliothèque ggplot2 a

été introduite en 2009, avant l'introduction du système des pipes dans le langage R.
Pré-requis
Dans cette section, l'exemple utilise la base de données des députés déjà utilisée auparavant, en
travaillant avec la bibliothèque ggplot2.
library(dplyr)
library(ggplot2)
library(readr)
table_deputes <- read_csv("data/table_deputes.csv")
Choix de la géométrie
Pour réaliser un diagramme en barres, on utilise la géométrie geom_bar(). Ici, on associe à l'axe
des abscisses le genre et on associe la statistique de comptage au genre.
table_deputes %>%
ggplot() +
geom_bar(
mapping = aes(x = genre),
https://fr.wikibooks.org/wiki/Programmer_en_R/Comprendre_la_grammaire_des_graphiques 1/2
28/11/2021 00:50 Programmer en R/Comprendre la grammaire des graphiques — Wikilivres
stat = "count"
On peut aussi préciser les échelles, le titre, le sous-titre, etc.
table_deputes %>%
ggplot() +
geom_bar(
mapping = aes(x = genre, fill = genre),
stat = "count"
) +
scale_x_discrete(name = "Genre") +
scale_y_continuous(name = "Nombre de députés") +
scale_fill_discrete() +
labs(
title = "Répartition des députés par genre",
subtitle = "Période 2012-2017",
caption = "Source : Liste des députés publiés par Wikimédia France sur
data.gouv.fr"
1. http://r4ds.had.co.nz/data-visualisation.html
Voir aussi
Hadley Wickham, « A Layered Grammar of Graphics », Journal of Computational and
Graphical Statistics, vol. 19, no. 1, pp. 3–28, 2010.
title=Programmer_en_R/Comprendre_la_grammaire_des_graphiques&oldid=636959 »
https://fr.wikibooks.org/wiki/Programmer_en_R/Comprendre_la_grammaire_des_graphiques 2/2
28/11/2021 00:51 Programmer en R/Représenter une carte — Wikilivres
Le langage R permet de réaliser des cartes.
Réalisation d'une carte des départements français
Import des données
On peut télécharger les contours des départements français sur le site data.gouv.fr [1] . On peut
importer les données au format Shapefile grâce à la fonction readOGR() de la librairie rgdal :
library(rgdal)
spdf_departement <- readOGR(
"data/departements-20140306-100m-shp/",
layer= "departements-20140306-100m"
On obtient alors un SpatialPolygonDataFrame.
Visualisation avec la fonction de visualisation de base
Pour visualiser uniquement, les départements de la métropole, on peut sélectionner les

départements dont le code Insee ne prend que deux caractères. On utilise la fonction
str_length() de la librairie stringr. Pour clarifier le code, on utilise l'opérateur %>% de la
librairie magrittr. Cet opérateur permet d'enchaîner les fonctions les unes à la suite des autres.
library(stringr)
library(magrittr)
spdf_departement %>%
subset(. , str_length(code_insee) == 2)
On peut ensuite créer une première visualisation avec la fonction plot().
library(stringr)
library(magrittr)
subset(. , str_length(code_insee) == 2) %>%
plot()
Visualisation avec la librairie ggplot2
https://fr.wikibooks.org/wiki/Programmer_en_R/Représenter_une_carte 1/3
Pour réaliser la carte avec la librairie ggplot2, il faut au préalable transformer le

SpatialPolygonDataFrame en data frame à l'aide de la fonction fortify. Pour réaliser cette
opération, il est nécessaire de charger les paquets rgeos, maptools et ggplot2.
library(ggplot2)
library(rgeos)
library(maptools)
df_departement <- fortify(spdf_departement, region = "code_insee")
Comme dans l'exemple plus haut, on peut filtrer les départements de France métropolitaine avec
la fonction str_length() du paquet stringr et la fonction filter du paquet dplyr.
library(dplyr)
df_departement %>%
filter(str_length(id) == 2)
On réalise ensuite la carte avec ggplot() :
library(dplyr)
df_departement %>%
filter(str_length(id) == 2) %>%
ggplot() +
geom_polygon(
mapping = aes(x = long, y = lat, group = group),
color = "grey", fill = "white") +
coord_map(projection = "mercator") +
theme(axis.text = element_blank(),
axis.title = element_blank()) +
labs(title = "Carte des départements de France métropolitainee en 2014")
Visualisation interactive avec Leaflet
La librairie leaflet permet de réaliser facilement une carte interactive depuis R.

Pour cela, il faut
utiliser le SpatialPolygonDataFrame, celui que nous avons nommé spdf_departement. La syntaxe
est très simple. La fonction addTiles() permet d'ajouter un fond de carte. La fonction
addPolygons permet d'ajouter les polygones.
library(leaflet)
library(stringr)
library(magrittr)
subset(. , str_length(code_insee) == 2) %>%
leaflet() %>%
addTiles() %>%
addPolygons()
1. https://www.data.gouv.fr/fr/datasets/contours-des-departements-francais-issus-d-
openstreetmap/
title=Programmer_en_R/Représenter_une_carte&oldid=636961 »
28/11/2021 00:51 Programmer en R/Visualiser une carte choroplèthe — Wikilivres
R permet la création de cartes.
Coloriage des départements Français
Pour illustrer la géographie de la démographie française, on peut colorier les différents département selon le taux
d'accroissement de la population.
L'INSEE fournit les données de population par commune, on les enregistre dans un fichier csv (population.csv) sous
la forme :
"DEPCOM" "DEP" "DEPPCT" "LIBMIN" "PSDC99" "PSDC90"
1001 1 110 "L'Abergement-Clémenciat" 728 579
1002 1 101 "L'Abergement-de-Varey" 168 159
1004 1 101 "Ambérieu-en-Bugey" 11436 10455
1005 1 130 "Ambérieux-en-Dombes" 1408 1156
1006 1 104 "Ambléon" 86 76
Les données INSEE comportent de nombreuses autres colonnes qui ne nous intéressent pas ici.
On aura également besoin d'un fichier departement.csv pour lier les numéro de département a leurs nom.
"DEP" "NOM"
01 "Ain"
02 "Aisne"
03 "Allier"
04 "Alpes-de-Haute-Provence"
05 "Hautes-Alpes"
Il n'y a plus qu'a tracer la carte :
> library (maps)
> map ('france')
> title (main="Taux d'evolution de la population entre 1990 et 1999")
> DATA <- read.table ("population.csv", header=TRUE)
> df <- aggregate (data.frame (PSDC99=DATA$PSDC99, PSDC90=DATA$PSDC90), by=list(DATA$DEP),

FUN = sum)
> df$TAUX <- (df$PSDC99-df$PSDC90)/df$PSDC90*100
> DEP <- read.table ("departement.csv", header=TRUE)
> df <- merge (df, DEP, by.x="Group.1", by.y="DEP")
> df$CLASS <- cut (df$TAUX, c(-Inf, -6, -4, -2, 0, 2, 4, 6, Inf), right=TRUE)
> col <- c(rgb (1:4/4, 0, 0), rgb (0, 4:1/4, 0))
> map ('france', regions=df$NOM, col=col[df$CLASS], fill=TRUE, add=TRUE, exact=TRUE)
> legend ('bottomleft', legend=attr (df$CLASS, 'levels'), col=col, lty=1, lwd=10)
> box()
On obtient alors le résultat :
https://fr.wikibooks.org/wiki/Programmer_en_R/Visualiser_une_carte_choroplèthe 1/2
28/11/2021 00:51 Programmer en R/Visualiser une carte choroplèthe — Wikilivres
De premier abord, ce genre de carte n'est pas évident à obtenir, mais une fois le principe compris, cela devient
extrêmement efficace. Nous y reviendrons dans le chapitre Créer des cartes.
Récupérée de « https://fr.wikibooks.org/w/index.php?title=Programmer_en_R/Visualiser_une_carte_choroplèthe&oldid=636963 »
Les textes sont disponibles sous licence Creative Commons attribution partage à l’identique ; d’autres termes peuvent s’appliquer.
https://fr.wikibooks.org/wiki/Programmer_en_R/Visualiser_une_carte_choroplèthe 2/2
28/11/2021 00:52 Programmer en R/Estimer un modèle de régression linéaire — Wikilivres
Manière simple
Considérons une loi affine à deux dimensions,
y = a + bx.
Le plus simple pour faire la régression consiste à utiliser la commande line (au singulier).
Commençons par générer les données :
u1 <- seq(0, 1, 0.01) # abscisse, variable explicative x
u2 <- 2*u1 + rnorm(u1, 0, 0.1) # ordonnée, variable expliquée y
La régression se fait simplement par
modele <- line(u1, u2)
print(modele)
ce qui donne
Call:
line(u1, u2)
Coefficients:
[1] -0.01580 2.02439
Le modèle est donc
y = - 0,015,80 + 2,024,39·x
Puis, nous traçons les données et la droite de régression :
plot(u1, u2)
abline(modele)
Manière complète
La manière « complète » permet d'étendre la régression à des dimensions supplémentaires

(régression multilinéaire), et donne plus d'informations.
Pour effectuer une régression, il faut créer une structure de données (data frame) et un modèle. Le
modèle est une formule symbolique :
https://fr.wikibooks.org/wiki/Programmer_en_R/Estimer_un_modèle_de_régression_linéaire 1/11
y ~ x pour un modèle affine (droite avec ordonnée à l'origine) du type y = a + bx ;

y ~ x + 0 pour un modèle linéaire (ordonnée à l'origine nulle) du type y = bx.
La régression linéaire se fait avec la fonction lm(formule, structure de données) (linear

model).
À partir du même jeu de données
u1 <- seq(0, 1, 0.01) # abscisse, variable explicative
u2 <- 2*u1 + rnorm(u1, 0, 0.1) # ordonnée, variable expliquée
nous construisons la structure de données et effectuons la régression
donnees <- data.frame(u1, u2)
modele <- lm(u2~u1, donnees)
print(modele)
summary(modele)
ce qui donne
Call:
lm(formula = u2 ~ u1, data = donnees)
Coefficients:
(Intercept) u1
-0.0158 2.0244
Call:
lm(formula = u2 ~ u1, data = donnees)
Residuals:
Min 1Q Median 3Q Max
-0.27014 -0.06658 -0.00200 0.07255 0.33107
Coefficients:
Estimate Std. Error t value Pr(>|t|)
(Intercept) -0.01580 0.02008 -0.787 0.433
x 2.02439 0.03469 58.352 <2e-16 ***
---
Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1
Residual standard error: 0.1016 on 99 degrees of freedom
Multiple R-squared: 0.9717, Adjusted R-squared: 0.9715
F-statistic: 3405 on 1 and 99 DF, p-value: < 2.2e-16
Le modèle établi par régression est donc
u2 = 2,024,39·u1 - 0,015,80
avec un écart quadratique de 0,101,6.
Puis nous traçons les points et la droite de régression (ici en rouge) :
plot(u1, u2)
abline(modele, col="red") # droite y = ax + b de couleur rouge
Nous pouvons ensuite utiliser ce modèle pour calculer de nouvelles valeurs de y pour des valeurs
de x données, avec un intervalle de confiance. Par exemple, pour avoir y en 0,3, 0,5 et 0,7 avec un
intervalle de confiance de 0,95 (95 %) :
valeurs <- c(0.3, 0.5, 0.7)
predict(modele, data.frame(u1 = valeurs), level = 0.95, interval =

"confidence")
Procédure simple
Considérons deux jeux de données u1 et u2 que nous

supposons corrélées par une loi affine
u2 = a + b×u1 + ε
où ε est l'écart, qui suit une variable aléatoire centrée sur 0 et

d'écart type uniforme.
La première étape consiste à calculer le coefficient de

corrélation linéaire pour vérifier notre hypothèse. Cela se fait
avec la fonction cor() :
Tracé obtenu.
cor(u1, u2)
L'interprétation de ce coefficient dépend du domaine étudié, mais plus la valeur absolue est proche
de 1, plus les données « collent » au modèle affine. On s'attache souvent à avoir une valeur absolue
supérieure à 0,8 ; elle doit être en tous cas supérieure à 0,5.
La régression proprement dite se fait ensuite avec la fonction line() :
print(modele)
Cette fonction utilise la méthode médiane-médiane, dite aussi « droite robuste de Tukey ».
Par exemple :
# ********************
# Création des données
u2 <- 2*u1 + rnorm(u1, 0, 0.1) # ordonnée, variable expliquée
# **************************
# Coefficient de corrélation
coefcorr <- cor(u1, u2)
# ****************************
# Régression linéaire de Tukey
# *********
# Affichage
print(paste("Coefficient de corrélation linéaire : ",
1e-3*round(1e3*coefcorr)))
print("Modèle de Tukey : ")
print(modele)
donne (aux variations du tirage aléatoire près) :
[1] "Coefficient de corrélation linéaire : 0.986
[1] "Modèle de Tukey : "
Call:
line(u1, u2)
Coefficients:
[1] 0.03007 1.93965
Le modèle est donc ici :
u2 = 0,030,07 + 1,939,65×u1 + ε.
Nous pouvons extraire les paramètres avec modele$coefficients, qui est un vecteur, ou la
fonction coef(modele) qui retourne également un vecteur. Cela permet tracer les données en
superposant la droite aux données :
# *****
# Tracé
plot(u1, u2)
abline(modele)
On peut extraire les coefficients de la manière suivante :
# Première manière
a <- coef(modele)[1]
b <- coef(modele)[2]
# Seconde manière
a <- modele$coefficients[1]
b <- modele$coefficients[2]
Procédure complète
Une fois cette régression faite, il faut poursuivre par les tests de nullité : les coefficients a et b sont-
ils significativement non nuls ? Cela nécessite de calculer l'estimateur de la variance sur a et b,
puis, le cas échéant, de faire une régression en forçant le passage de la droite par l'origine.
Pour cela, on fait appel à la fonction lm(), qui utilise elle la méthode des moindres carrés. Cette
fonction nécessite de définir le modèle utilisé sous la forme d'une « formule », une description
symbolique du modèle. Une formule est introduite par le tilde ~. Les deux formules que nous
utilisons ici sont :
u2 ~ u1 # modèle affine
u2 ~ u1 + 0 # modèle linéaire
La régression se fait de la manière suivante :
# ******************************
# régression des moindres carrés
modele <- lm(u2~u1, donnees)
print("Modèle des moindres carrés : ")
print(modele)
plot(u1, u2)
abline(modele)
Au passage, on remarque que les coefficients obtenus sont légèrement différents. Puis, on effectue
le test de non nullité de b et de a (coefficient 3 pour un intervalle de confiance de 99,7 %) :
# ********************
# Tests de non nullité
alpha <- 0.05 # risque alpha (intervalle de confiance 1 - alpha)
sommaire <- summary(modele)
# test sur b
student_b <- sommaire$coefficients[2,4]
b_non_nul <- student_b <= (alpha/2)
print("Test de non nullité de b.")
print(paste("Hypothèse 1, les données sont corrélées : ", b_non_nul))
# Test sur a
ecart_type_a <- sommaire$coefficients[1,2]
student_a <- sommaire$coefficients[1,4]
a_non_nul = student_a <= (alpha/2)
# Affichage
print("Test de non nullité de a.")
print(paste("Hypothèse 1, a est non nul : ", a_non_nul))
ce qui nous donne ici :
[1] "Test de non nullité de b."
[1] "Hypothèse 1, les données sont corrélées : TRUE"
[1] "Test de non nullité de a."
[1] "Hypothèse 1, a est non nul : FALSE"
On refait donc une régression linéaire en forçant a = 0 :
if (!a_non_nul) { # si l'ordonnée à l'origine est nulle
modele <- lm(u2~u1 + 0, donnees) # régression passant par l'origine
a <- 0
b <- coef(modele)
sommaire <- summary(modele)
ecart_type_b = sommaire$coefficients[1]
} else {
a <- coef(modele)[1]
b <- coef(modele)[2]
ecart_type_b = sommaire$coefficients[2,2]
abline(modele) # tracé du modèle
print(modele)
Puis, on calcule les erreur standard sur a, b, et sur l'estimation des y si l'on utilise le modèle (en
considérant un grand nombre de valeurs et un intervalle de confiance de 99,7 %) :
# **********************
# Estimation des erreurs
coef_erreur = qnorm(1-alpha/2)
b <- modele$coefficients[2]
erreur_b <- coef_erreur*ecart_type_b
a <- modele$coefficients[1]
erreur_a <- coef_erreur*ecart_type_a
erreur_y <- coef_erreur*summary(modele)$sigma
odgea <- round(log10(erreur_a)) # ordre de grandeur pour arrondi
odgeb <- round(log10(erreur_b))
odgey <- round(log10(erreur_y))
err_a <- 10^(odgea - 2)*round(erreur_a*10^(-odgea + 2))
err_b <- 10^(odgeb - 2)*round(erreur_b*10^(-odgeb + 2))
err_y <- 10^(odgey - 2)*round(erreur_y*10^(-odgey + 2))
print(paste("Erreur sur a : ", err_a))
print(paste("Erreur sur b : ", err_b))
print(paste("Erreur sur y au centre : ", err_y))
ce qui donne
[1] "Erreur sur a : 0.0058"
[1] "Erreur sur b : 0.01"
[1] "Erreur sur y au centre : 0.294"
On peut afficher différents graphiques de synthèse avec
layout(matrix(1:4,2,2)) # fenêtre de 2x2 graphiques
plot(modele)
qui comprend :
les résidus en fonction de x ;

les résidus normalisés en fonctions de x ;
la droite de Henry (quantiles-quantiles) des résidus (permet de vérifier si le résidu suit une loi
normale centrée) ;
les résidus normalisés en fonction du levier (x - x).
Comparaison avec un modèle a priori
Nous avons vérifié si les paramètres obtenus étaient différents de zéro de manière significative.
Mais on peut aussi vérifier s'ils sont différent d'une valeur a priori. La commande
pt(x, n)
donne la fonction de répartition de la loi de Student à n degrés de liberté (voir Les loi de
probabilités, ajustement et test), c'est-à-dire la probabilité d'avoir une valeur inférieure ou égale à
x, et la fonction
pt(x, n, lower.tail = FALSE)
calcule la probabilité complémentaire. Le paramètre βi est estimé par la valeur bi, avec
βi = bi ± t1-α/2, n×si
on peut donc calculer le coefficient de student
la fonction pt() nous renvoyant la valeur de 1-α/2, ou de α/2 avec l'option lower.tail = FALSE.
Ici, nous savons que la valeur théorique est 2, donc
bth <- 2
tb <- abs(bth - b)/ecart_type_b
pr_b_similaire_bth <- 2*pt(tb, length(u1)-2, lower.tail = FALSE)
Utilisation du modèle
Au delà du calcul des paramètres du modèle, R permet d'exploiter ce modèle, c'est-à-dire qu'il
calcule la valeur de y pour un x donné, et fournit avec l'intervalle de confiance. Cela se fait avec la
commande
predict(modele, donnees_X, level = …, interval = "confidence")
où
donnees_X est un data.frame ;

la valeur de l'attribut level est le niveau de confiance (0.9 pour 90 %).
Par exemple, pour avoir la valeur de y en 0,3, 0,5 et 0,7 avec un inetrvalle d econfiance de 95 % :
> valeurs <- c(0.3, 0.5, 0.7)
> predict(modele, data.frame(u1 = valeurs), level = 0.95, interval =

"confidence")
fit lwr upr
1 0.6041944 0.5930618 0.6153269
2 1.0069906 0.9884364 1.0255449
3 1.4097869 1.3838109 1.4357628
Autres fonctions utiles
Une fois le modèle établi, on peut récupérer :
les résidus avec resid(modele) ;

les valeurs prédites par le modèle avec fitted(modele).
Lorsque le modèle est linéaire pour les coefficients mais pas pour les fonctions des variables
explicatives, on peut vérifier graphiquement l'adéquation du modèle avec fitted(modele). Par
exemple, pour un modèle de type
u2 = a + b⋅u12 + ε
# ********************
u2 <- 2*u1^2 + rnorm(u1, 0, 0.05) # ordonnée, variable expliquée
# ******************************
modele <- lm(u2~I(u1^2), donnees)
print(modele)
plot(u1, u2)
lines(u1, fitted(modele))
Modèle à plusieurs variables
Le modèle linéaire peut être à plusieurs variables. Le

data.frame utilisé doit avoir une colonne par variable.
Considérons par exemple un modèle à deux variables
y = β0 + β1⋅x1 + β1⋅x2 + ε
alors les vecteurs x1, x2 et y doivent avoir même dimension et
y[i ] = β0 + β1⋅x1[i ] + β1⋅x2[i ] + ε[i ].
Par exemple :
Régression linéaire pour un modèle
à deux variables.
# ********************
# nombre de valeurs de chaque variable

explicative
n <- 5
# variables explicative
x1 <- seq(0, 1, length.out = n)
x2 <- seq(0, 1, length.out = n)
# répétition des valeurs pour mixer x1 et x2
x1.data <- rep(x1, each = n)
x2.data <- rep(x2, n)
# variable expliquée
y = 1 + 2*x1.data + 3*x2.data + rnorm(n^2, 0,

0.4)
# ******************************
donnees <- data.frame(x1.data, x2.data, y)
modele <- lm(y ~ ., donnees)
print(modele)
# ************************
# représentation graphique
# tracé des données
VT <- persp(x1, x2, matrix(y, n, n))
# traces du plan modèle
mx1 <- min(x1) ; mx2 <- min(x2)
Mx1 <- max(x1) ; Mx2 <- max(x2)
Mzx <- trans3d(Mx1, mx2, fitted(modele)[n],

VT)
Myz <- trans3d(mx1, Mx2, fitted(modele)[n*(n-

1)+1], VT)
lines(c(Minit[1], Mzx[1]), c(Minit[2],

Mzx[2]), lwd = 2)
lines(c(Minit[1], Myz[1]), c(Minit[2],

Myz[2]), lwd = 2)
donne
[1] "Modèle des moindres carrés : "
Call:
lm(formula = y ~ ., data = donnees)
Coefficients:
(Intercept) x1.data x2.data
1.269 1.717 2.966
title=Programmer_en_R/Estimer_un_modèle_de_régression_linéaire&oldid=636964 »
28/11/2021 00:52 Programmer en R/Estimer un modèle de régression circulaire — Wikilivres
Nous allons effectuer une régression

circulaire en utilisant la méthode
directe de Kåsa et Coope, qui est une
méthode de régression linéaire (voir
sur Wikipédia Régression circulaire
> Méthode de Kåsa et Coope). Pour
le calcul, nous utilisons l'équation
cartésienne du cercle de centre (xc,
yc) et de rayon r :
;
soit en développant :
Régression circulaire par la méthode de Kåsa et Coope avec GNU

R.
Pour le tracé, nous utilisons l'équation paramétrique :
Nous utilisons les données proposées par D. Gruntz [1]
Données
pour la
régression
circulaire
x y
0.7 4.0
3.3 4.7
5.6 4.0
7.5 1.3
6.4 -1.1
4.4 -3.0
0.3 -2.5
-1.1 1.3
data.entry('x', 'y') # copier les données ci-dessus
# cliquer sur l'en-tête des colonnes pour sélectionner "numeric"
# puis fermer la table
plot(x, y, col='blue')
https://fr.wikibooks.org/wiki/Programmer_en_R/Estimer_un_modèle_de_régression_circulaire 1/3
Puis, nous effectuons la régression
donnees <- data.frame(x, y)
cercle <- lm(I(x^2 + y^2) ~ x + y, donnees)
print(cercle)
ce qui donne
Call:
lm(formula = I(x^2 + y^2) ~ x + y, data = donnees)
Coefficients:
(Intercept) x y
6.967 6.121 1.487
Le modèle obtenu par régression est donc :
(x2 + y2) = 6,121·x + 1,487·x + 6,967.
Enfin, nous déterminons les caractéristiques du cercle
xc <- coef(cercle)[2]/2
yc <- coef(cercle)[3]/2
r <- sqrt(coef(cercle)[1] + xc^2 + yc^2)
print(xc) ; print(yc) ; print(r);
ce qui donne
3.060304
0.7436073
(Intercept)
4.109137
soit un cercle de centre (3,060,304 ; 0,743,607,3) et de rayon 4,109,137. Puis nous traçons le
modèle
theta <- seq(0, 2*pi, len = 40)
xmodcercle <- xc + r*cos(theta)
ymodcercle <- yc + r*sin(theta)
lines(xmodcercle, ymodcercle, col='red')
1. anglais D. Gruntz, « Finding the Best Fit Circle », dans The MathWorks Newsletter, vol. 1,
1990, p. 5
title=Programmer_en_R/Estimer_un_modèle_de_régression_circulaire&oldid=636968 »
28/11/2021 00:52 Programmer en R/Programmer une boucle — Wikilivres
Boucle itérative
La structure générale d'une boucle itérative est :
for (variable in vecteur)
instruction
où variable est un nom de variable, et vecteur est un vecteur contenant les valeurs successive que
va prendre la variable. Par exemple, pour calculer 10! (factorielle dix) « à la main » :
factorielle <-1
for (i in seq(1, 10))
factorielle <- factorielle*i
On pourra comparer cette valeur avec celle de Γ(11) = 10! : gamma(11).
Boucle anté- ou postconditionée
Le logiciel R dispose de deux instructions : repeat et while.
La structure
repeat bloc
répète le bloc. La structure ne possède pas en elle-même de condition d'arrêt ; celle-ci doit être
incluse dans le bloc considéré, la sortie de la boucle se faisant par la commande break. Par
exemple, le code ci-dessous calcule 10!, la variable i étant décrémentée :
i <- 10
factorielle <- 1
repeat {
i <- (i - 1)
if (i == 1) break
La structure while a pour syntaxe :
while (instruction1) instruction2
https://fr.wikibooks.org/wiki/Programmer_en_R/Programmer_une_boucle 1/2
28/11/2021 00:52 Programmer en R/Programmer une boucle — Wikilivres
où l'évaluation de instruction1 est un booléen, et instruction2 est exécutée si cette évaluation

renvoie « vrai ». Le calcul de la factorielle devient
i <- 10
factorielle <- 1
while (i > 1) {
i <- (i - 1 )
Pilotage des boucles
Il existe deux instruction permettant de piloter les boucles :
l'instruction break, comme nous l'avons déjà vu, permet d'interrompre une boucle ;
l'interpréteur exécute ensuite l'instruction qui suit la boucle ;
l'instruction next force le passage à l'itération suivantes : l'interpréteur exécute la première
instruction de la boucle.
title=Programmer_en_R/Programmer_une_boucle&oldid=636973 »
https://fr.wikibooks.org/wiki/Programmer_en_R/Programmer_une_boucle 2/2
28/11/2021 00:53 Programmer en R/Programmer une fonction — Wikilivres
Fonctions définies par l'utilisateur

Le logiciel R dispose de fonctions préprogrammées, appelées « primitives ». L'utilisateur a la
possibilité de définir ses propres fonctions.
Une fonction est un sous-programme, c'est-à-dire une portion de code qui est exécutée lorsqu'on
l'appelle.
Le logiciel R crée un environnement spécifique pour l'exécution de la fonction, c'est-à-dire qu'il

travaille avec des variables locales. Ainsi, une variable définie dans une fonction peut avoir le
même nom qu'une variable générale, ce sont deux variables indépendantes ; on peut modifier la
valeur de cette variable, mais elle retrouve sa valeur initiale lorsque l'on sort de la fonction.
Définition d'une fonction
Une fonction est mise dans une variable contenant un bloc d'instructions introduit par la
commande function(). La syntaxe générale est :
nom_de_fonction <- function(arguments) {
instructions
par exemple
> carre <- function(x) x*x
> carre(2)
[1] 4
L'évaluation de la fonction renvoie la dernière valeur calculée. On peut préciser la valeur retournée
par la commande return() :
nom_de_fonction <- function(arguments) {
instructions
return(valeur)
par exemple
carre <- function(x) {
y <- x*x
return(y)
https://fr.wikibooks.org/wiki/Programmer_en_R/Programmer_une_fonction 1/3
Fonctions sur les vecteurs
Les fonctions mathématiques primitives de R s'appliquent sur des vecteurs. On s'attachera donc à
créer des fonctions qui s'appliquent elles-mêmes à des vecteurs. Par exemple, la fonction suivante
permet de définir une courbe en cloche dissymétrique, formée de deux demies gaussiennes de
largeur différentes.
gauss_dissym <- function(A, x) {
# génère un pic gaussien dissymétrique
# entrées : A : vecteur de réels, paramètres de la fonction
# A[1] : position du pic
# A[2] : hauteur de la courbe
# A[3] : largeur de la courbe à gauche
# A[4] : largeur de la courbe à droite
# x : vecteur de réels
# sorties : y : vecteur de réels
indice <- (x < A[1]) # vecteur de T à gauche, F à droite
y <- rep(0, length(x)) # initialisation par des zéros
y[indice] <- A[2]*exp(-(x[indice] - A[1])^2/A[3]) # profil gauche
y[!indice] <- A[2]*exp(-(x[!indice] - A[1])^2/A[4]) # profil droit
return(y)
Le fait d'utiliser la matrice de booléens indice permet, au sein d'une seule fonction, de séparer les
cas x < A[1] et x ≥ A[1]. On peut donc utiliser cette fonction sur un vecteur :
x <- seq(-5, 5, len=100)
A <- c(1, 1, 2, 5)
y <- gauss_dissym(A , x)
plot(x, y, "l")
Si l'on n'arrive pas à faire autrement, on peut toujours faire défiler les indices avec une boucle,
mais l'évaluation de la fonction est alors plus lente.
Récursivité
Le langage S est un langage récursif. Une fonction définie dans un script R peut donc s'appeler
elle-même, avec la précaution d'usage : il faut prévoir une condition d'arrêt. Comme dans tous les
langages récursifs, R crée un environnement spécifique pour l'exécution de la fonction (variables
locales), il « empile » les différents appels, puis les « dépile » lorsque la condition d'arrêt est
atteinte.
Nous illustrons ceci par le codage récursif de la fonction factorielle.
factorielle <- function(n) {
if (n==1) resultat <- 1 # arrêt de la récursion
else resultat <- factorielle(n-1)*n # appel récursif
return(resultat)
Mais nous remarquons que cette fonction ne s'applique qu'aux scalaires, en raison de la présence
du test if (n == 1) : la condition if ne s'applique que sur un scalaire booléen. On peut modifier
le code pour le rendre exécutable sur les vecteurs :
factorielle <- function(n) {
indice <- (n == 1)
if (all(indice)) return(n) # arrêt de la récursion
n[!indice] <- n[!indice]*factorielle(n[!indice] - 1) # appel récursif
return(n)
Comme souvent, on crée un vecteur de booléens appelé indice. Si toutes les valeurs sont à « 1 »,
alors on retourne le vecteur lui-même (puisque 1! = 1) ; c'est l'arrêt de la récursion. Sinon, on
extraie le sous-vecteur dont les valeurs ne sont pas « 1 », et l'on applique la récursion.
On peut le tester avec par exemple
> x = c(1:5, 1:5)
> print(x)
[1] 1 2 3 4 5 1 2 3 4 5
> factorielle(x)
[1] 1 2 6 24 120 1 2 6 24 120
title=Programmer_en_R/Programmer_une_fonction&oldid=636974 »
28/11/2021 00:53 Programmer en R/Optimiser une fonction — Wikilivres
Les méthodes d'optimisation sont des méthodes numériques de recherche du minimum ou

d'un maximum d'une fonction.
Soit une fonction ƒ à valeurs réelles, définie sur un espace vectoriel de dimension n :
y = ƒ(x1, x2, …, xn)
On recherche le minimum de ƒ, c'est-à-dire un vecteur (x1*, x2*, …, xn*) tel que la valeur de ƒ soit
la plus petite possible.
Les méthodes de régression consistent à ajuster un modèle à des données. Elles consistent à
minimiser une fonction d'écart, à l'optimiser.
Méthode d'optimisation sans contrainte
Fonction sans paramètre
Dans le cas d'une optimisation sans contrainte, R propose la commande optimise() ou

optimize() (synonymes). Sa syntaxe globale est :
optimize(fct, intervalle)
optimize(fct, intervalle, maximum = TRUE)

optimize(f = fct, interval = intervalle)
où
fct est la fonction à minimiser, voir Programmation procédurale > Fonctions définies par
l'utilisateur ;
intervalle est l'intervalle sur lequel il effectue la recherche ;
maximum = est un booléen : « vrai » si l'on cherche la maximum, « faux » (valeur par défaut)
si l'on cherche le minimum.
Si par exemple on désire connaître le minimum de la fonction
ƒ(x) = sin(x)
sur l'intervalle [-π ; π], on peut écrire
f <- function(x) sin(x)
minf <- optimize(f, c(-pi, pi))
maxf <- optimize(f, c(-pi, pi), maximum = TRUE)
print(minf$minimum)
print(minf$objective)
https://fr.wikibooks.org/wiki/Programmer_en_R/Optimiser_une_fonction 1/11
print(maxf$maximum)
print(maxf$objective)
ce qui nous donne
[1] -1.570798
[1] -1
[1] 1.570798
[1] 1
Donc, le minimum est en −1,570,798, qui est une approximation de -π/2 ≃ −1,570,796, et la
fonction y vaut -1. Le maximum est en 1,570,798, qui est une approximation de π/2, et la fonction
y vaut 1.
On peut aussi utiliser la syntaxe
minf <- optimize(f, lower = -pi, upper = pi)
maxf <- optimize(f, lower = -pi, upper = pi, maximum = TRUE)
On peut lui indiquer la tolérance visée sur le résultat, avec l'option tol =. Par exemple, pour avoir
une précision de 10-6 :
optimize(f, c(-pi, pi), tol = 1e-6)
Nous disposons également de la commande optim() ; elle ne cherche que le minimum, elle ne
permet pas par défaut de définir un intervalle, et il faut lui donner un point de départ ; par contre,
elle permet de travailler avec des fonctions de plusieurs variables. Sa syntaxe globale est :
optim(x0, f)
où
x0 est un vecteur de valeurs initiales ;

f est la fonction à minimiser.
Si par exemple on désire connaître le minimum de la fonction
ƒ(x) = 5x2 + 3x - 4
on peut écrire (en utilisant la méthode de Horner pour calculer le polynôme)
f <- function(x) (5*x + 3)*x - 4
x0 = 0
solution = optim(x0, f)
Le solveur nous donne un message d'avertissement qui est sans conséquence.

L'abscisse de la solution est donnée par
> solution$par
[1] -0.3
qui est la solution exacte [1] , et la valeur de la fonction en ce point est
> solution$value
[1] -4.45
Si l'on affiche la totalité de la solution, on obtient
> solution
$par
[1] -0.3
$value
[1] -4.45
$counts
function gradient
26 NA
$convergence
[1] 0
$message
NULL
qui nous indique :
$count : le nombre de fois (26) qu'il a fallu appeler la fonction f ; c'est globalement le nombre
d'itérations qui a été nécessaire pour trouver la solution ;
$convergence : la qualité de la convergence ; « 0 » indique que la méthode a bien
convergé ;
$message : un message éventuel du solveur (aucun).
La commande permet donc de travailler avec une fonction de plusieurs variables, par exemple si
l'on considère la fonction
ƒ(x, y) = x2 + y2 - 10x - 8y + 41
on peut trouver son minimum avec
f <- function(x) x[1]^2 + x[2]^2 - 10*x[1] - 8*x[2] + 16
x0 <- c(0, 0)
solution <- optim(x0, f)
print(solution$par)
print(solution$value)
ce qui donne
[1] 4.999483 4.000116
[1] -25
La solution exacte est x = 5 et y = 4 [2] .
Fonction avec paramètre
Si la fonction possède des paramètres, on doit les passer en utilisant leur nom exact. Par exemple,
si la fonction est
ƒa, b, c(x, y) = (x - a)2 + (y - b)2 + c
alors le script suivant permet de trouver le minimum :
f <- function(x, a, b, c) (x[1] - a)^2 + (x[2] - b)^2 + c
x0 <- c(0, 0)
solution <- optim(x0, f, a = 5, b = 4, c = -25)
print(solution$par)
print(solution$value)
ce qui donne
[1] 4.999483 4.000116
[1] -25
Méthode d'optimisation avec contrainte linéaire

On recherche le minimum de ƒ, mais avec des contraintes linéaires, de type :
inégalités : ui×xi ≥ ci
Le logiciel R propose la commande constrOptim(), qui fait appel au solveur optim() mais en
ajoutant une fonction de pénalité pour gérer les contraintes. La syntaxe de base est :
constrOptim(x0, f, NULL, u, c)
constrOptim(par = x0, fn = f, ui = u, ci = c)
où
x0 est le vecteur de départ, qui doit être dans la zone de faisabilité, c'est-à-dire vérifier les
inégalités de contrainte ;
f est la fonction ;
NULL indique que l'on ne définit pas la fonction gradient ;
u et c sont des vecteurs représentant les contraintes.
Par exemple, si l'on veut rechercher le minimum de la fonction y = sin(x) sur l'intervalle [-π ; π] :
la fonction f est sin

les contraintes linéaires sont
1×x ≥ -π,
-1×x ≥ -π
donc on a en notation matricielle u×x =c avec
et ;
on part de x0 = 0.
x0 <- matrix(0, 1, 1)
f <- sin
u <- matrix(c(1, -1), 2, 1)
c <- matrix(c(-pi, -pi), 2, 1)
solution <- constrOptim(x0, f, NULL, u, c)
La résolution provoque des messages d'avertissement, qui sont sans conséquence ici. L'abscisse de
la solution est donnée par
> solution$par
[,1]
[1,] -1.57066
qui est une approximation de -π/2 ≃ -1,570,8 ; la valeur de la fonction en ce point est donnée par
> solution$value
[,1]
[1,] -1
Si l'on affiche la totalité de la solution, on obtient
$par
[,1]
[1,] -1.57066
$value
[,1]
[1,] -1
$counts
function gradient
62 NA
$convergence
[1] 0
$message
NULL
$outer.iterations
[1] 3
$barrier.value
[,1]
[1,] -0.0008014317
qui nous indique, en plus des données d'optim() :
$outer.iterations : le nombre d'itération « extérieures », c'est-à-dire ici d'appels au

solveur optim() ;
$barrier.value : c'est, lors de la dernière itération, la valeur du paramètre de pénalisation
qui permet d'éviter de sortir des limites imposées.
Les différents algorithmes d'optimisation

Jusqu'ici, nous avons utilisé les méthodes d'optimisation par défaut. Selon les problèmes que l'on
aborde, on peut avoir intérêt à utiliser d'autres algorithmes.
Fonction optimize()
La fonction optimize() utilise la méthode du nombre d'or associée à une interpolation

parabolique.
Fonctions optim() et constrOptim()
Méthode de Nelder-Mead
Par défaut, la fonction optim() utilise la méthode de Nelder-Mead. Il consiste à prendre un

simplexe — deux points sur une courbe, trois points sur une surface, … — et d'étendre ce simplexe
vers les directions où la fonction est plus petite, puis à réduire ce simplexe lorsque le minimum est
à l'intérieur.
Cet algorithme fonctionne lorsque la fonction n'est pas dérivable (mais elle doit être continue). Par
contre, il n'est pas adapté aux problèmes à une dimension (fonction d'une seule variable), il vaut
alors mieux utiliser la méthode de Brent ou bien la fonction optimize().
Méthode BFGS
Le deuxième algorithme proposé est celui de BFGS, avec l'option method = "BFGS". C'est un
algorithme à direction de descente : à partir d'une point de départ, on se déplace sur le plan
tangent à la surface, vers le bas. La direction de descente est l'opposé du gradient de la fonction.
Le pas de descente est fonction l'inverse de la courbure : si la courbure est importante, alors la
surface s'écarte vite du plan tangent, il ne faut donc pas aller trop loin. L'algorithme calcule donc
une approximation de l'inverse de cette dérivée seconde, ou plutôt, dans le cas d'une fonction de
plusieurs variables, de la matrice hessienne (contenant les dérivées partielles d'ordre 2).
On peut fournir la fonction gradient, avec le troisième paramètre gr = … ; sinon, le solveur utilise
une approximation par différences finies. Par exemple
x0 = 0
solution <- optim(x0, f, method = "BFGS")
ou bien
g <- function(x) cos(x)
x0 = 0
solution <- optim(x0, f, g, method = "BFGS")
# syntaxe alternative : optim(x0, f, gr = g, method = "BFGS")
L'option hessian = TRUE retourne également la matrice hessienne calculée à la solution. On peut
aussi calculer la matrice hessienne par
optimHess(solution$par, f)
où solution$par est la solution trouvée par optimisation.
Le solveur propose une méthode BFGS modifiée, method = "L-BFGS-B", qui permet de définir
des limites inférieures et supérieures aux variables.
optim(x0, f, lower = …, upper = …, method = "L-BFGS-B")
Méthode du gradient conjugué
Le troisième algorithme proposé est celui du gradient conjugué, avec l'option method = "CG".
Cette méthode ne calcule pas, et donc ne stocke pas, les matrices hessiennes ; elle permet donc de
traiter des problèmes plus volumineux que la méthode BFGS, mais est moins robuste.
Le solveur accepte l'option hessian = TRUE.
Méthode du recuit simulé

Le quatrième algorithme proposé est celui du recuit simulé (simulated annealing), avec l'option
method = "SANN". Le but de cette méthode est d'éviter de trouver un minimum local. Pour cela,
une fois qu'une solution est trouvée, le solveur repart d'un autre point pour voir s'il converge vers
une autre valeur. Cette méthode est utile lorsqu'il y a de nombreux minima locaux (surface
« rugueuse »).
Méthode de Brent
Le quatrième algorithme proposé est la méthode de Brent, avec l'option method = "Brent". Ce
solveur ne traite que des problèmes à une dimension, et est en fait similaire à la fonction
optimize(). En particulier, il faut définir l'intervalle de recherche avec les options lower = … et
upper = …, mais il faut par contre toujours donner un point de départ.
optim(x0, f, lower = …, upper = …, method = "Brent")
Méthode de la barrière logarithmique
Pour la gestion des contrainte, la fonction constrOptim() utilise la méthode de la barrière

logarithmique. Cette méthode consiste à ajouter à la fonction ƒ une fonction de pénalité qui
augmente lorsque l'on s'approche de la frontière. Si l'inégalité de contrainte s'écrit sous la forme
h(x) ≥ 0
alors R prend pour fonction de pénalité
μ×ln(h(x))
où μ est une constante positive. Cette constante vaut par défaut 10<spu>-4, mais peut être
ajustée :
constrOptim(x0, f, NULL, u, c, mu = …)
Une méthode consiste à faire des passes successives en diminuant au fur et à mesure la valeur de μ
pour affiner le résultat, la fonction optimisée étant de plus en plus proche de la fonction initiale.
Modèle linéaire généralisé
La régression des moindres carrés consiste à minimiser l'estimateur de la variance ; cette

démarche est pertinente si le bruit suit une distribution normale ayant le même écart type. La
commande glm() permet d'utiliser d'autres distributions, avec le paramètre family.
Régression non-linéaire
Notons tout d'abord qu'une régression linéaire est un modèle dans lequel on recherche des
coefficients (β0, β1, …, βm) ; c'est l'expression de ces coefficients qui doit être linéaire, du type :
y = β0 + β1⋅ƒ1(x) + β2⋅ƒ2(x) + … + βm⋅ƒm(x)
où x est un vecteur (x1, x2, …, xn). Les fonctions ƒi ne sont pas nécessairement linéaires.
Un modèle non-linéaire est un modèle dans lequel les coefficients βi figurent eux-même de
manière non-linéaire dans une formule. Par exemple, si l'on recherche un modèle gaussien :
ce modèle n'est pas linéaire en β1 — notons qu'on peut le rendre linéaire en considérant le
logarithme de y.
La régression non-linéaire par la méthode des moindres carrés se fait avec la commande nls()
(nonlinear least squares). Par défaut, cette commande utilise la méthode de Gauss-Newton ; dans
tous les cas, il s'agit d'algorithmes itératifs. La syntaxe de base est similaire à celle de lm(), mais il
faut introduire explicitement les paramètres à affiner dans la formule. Par exemple :
# ********************
u1 <- seq(-1, 1, 0.01) # abscisse, variable explicative
u2 <- 2*exp(-3*u1^2) + rnorm(u1, 0, 0.1) # ordonnée, variable expliquée
# ******************************
modele <- nls(u2~b0*exp(-b1*u1^2), donnees)
print(modele)
plot(u1, u2)
lines(u1, fitted(modele), lwd = 2)
donne pour résultat :
[1] "Modèle des moindres carrés :"
Nonlinear regression model
model: u2 ~ b0 * exp(-b1 * u1^2)
data: donnees
b0 b1
1.975 2.965
residual sum-of-squares: 1.932
Number of iterations to convergence: 4
Achieved convergence tolerance: 5.148e-07
La valeur de départ de l'algorithme itératif est choisie automatiquement. On peut lui indiquer des
valeurs de départ avec le paramètre start, qui doit recevoir une liste nommée. par exemple, pour
commencer avec β0 = β1 = 1 :
modele <- nls(u2~b0*exp(-b1*u1^2), data = donnees, start = list(b0 = 1, b1

= 1))
Annexe : Formules symboliques

Le modèle de régression est une formule symbolique. Par exemple, si l'on écrit y ~ x, on utilise un
modèle affine (droite avec ordonnée à l'origine) du type
y = a + bx.
Pour une régression linéaire avec deux variables explicatives, on peut écrire y ~ x1 + x2 ; le
signe plus n'indique pas ici l'addition, mais sépare les deux paramètres, le modèle sera donc
y = a + b1x1 + b1x2.
Attention : les variables du modèle — x, x1, x2, y — doivent être les noms des variables utilisées
dans la structure de données.
Si l'on veut un modèle linéaire sans ordonnée à l'origine, on modifie la formule en ajoutant un
paramètre +0, par exemple y ~ x + 0.
Dans une formule symbolique, le signe plus indique que l'on combine linéairement deux variables.
Si l'on veut appliquer une addition stricte, c'est-à-dire additionner deux termes sans les assortir
d'un coefficient à définir par régression, il faut « inhiber l'interpréteur » avec la fonction I(), par
exemple :
formula = I(x^2 + y^2) ~ x + y
indique un modèle
x2 + y2 = a + b1x + b2y.
Formules symboliques dans R [3]

Syntaxe Modèle Commentaires
Y ~ X Y = β0 + β1X
Y ~ 0 + X Y = β1X
Y ~ X +
Y = β0 + β1X + β2X2
I(X^2)
Y ~ X1 + Y = β0 + β1X1 +
modèle du premier ordre sans interaction croisée
X2 β2X2
Y = β0 + β1X1 + … le point remplace toutes les colonnes des données (data.frame) non
Y ~ .
encore mentionnées dans la formule
Y ~ X1:X2 Y = β0 + β1X1X2 modèle ne contenant que des interactions croisée du premier ordre
Y = β0 + β1X1 + modèle du premier ordre complet
Y ~ X1*X2
β2X2 + β3X1X2 équivalent de Y ~ X1 + X2 + X1:X2
1. le minimum est atteint à ƒ' = 0 soit 10x + 3 = 0 soit x = -3/10

2. la fonction peut aussi s'écrire (x - 5)2 + (y - 4)2 - 25
3. Kristel Van Steen, Using R for Linear Regression, lire en ligne (http://www.montefiore.ulg.ac.b
e/~kvansteen/GBIO0009-1/ac20092010/Class8/Using%20R%20for%20linear%20regression.p
df)
title=Programmer_en_R/Optimiser_une_fonction&oldid=636979 »
28/11/2021 00:53 Programmer en R/Manipuler les matrices — Wikilivres
Notion de matrice
Une matrice est un tableau en deux dimensions dont tous les éléments sont du même type. À
l'instar des vecteurs, il ne s'agit pas ici de la notion algébrique de matrice, mais R dispose tout de
même des opérateurs matriciels classiques. Pour R, un vecteur n'est pas la même chose qu'une
matrice ligne ou colonne.
Initialisation d'une matrice ligne ou colonne
Une matrice colonne s'obtient avec la commande rbind (row bind, association de lignes) ; une
matrice ligne s'obtient avec la commande cbind (column bind, association de colonnes).
> rbind(1 ,2 ,3)
[,1]
[1,] 1
[2,] 2
[3,] 3
> cbind(1, 2, 3)
[,1] [,2] [,3]
[1,] 1 2 3
On peut initialiser une matrice avec des éléments tous identiques, avec la commande rep()
(replicate). Par exemple, pour créer des matrices nulles :
> rbind(rep(0, 3))
[,1] [,2] [,3]
[1,] 0 0 0
> cbind(rep(0, 3))
[,1]
[1,] 0
[2,] 0
[3,] 0
on remarque que l'utilisation de la commande rep() « inverse » le comportement ligne/colonne,

puisque rbind() met en ligne un seul élément (qui est un vecteur), et que cbind() met en colonne
un seul élément (qui est un vecteur).
Initialisation d'une matrice rectangulaire
Les matrices sont créées à partir d'un vecteur : les valeurs sont prises une par une pour remplir le
tableau, colonne par colonne.
https://fr.wikibooks.org/wiki/Programmer_en_R/Manipuler_les_matrices 1/6
Avec la commande rbind(), on associe plusieurs vecteurs, chaque vecteur étant une ligne du
tableau. Avec la commande cbind(), on associe plusieurs vecteurs, chaque vecteur étant une
colonne du tableau.
> rbind(c(1, 2, 3), c(4, 5, 6))
[,1] [,2] [,3]
[1,] 1 2 3
[2,] 4 5 6
> cbind(c(1, 2, 3), c(4, 5, 6))
[,1] [,2]
[1,] 1 4
[2,] 2 5
[3,] 3 6
On utilise également la commande matrix(). L'argument data (1er argument par défaut) est le
vecteur de données, l'argument nrow (2e par défaut) indique le nombre de lignes, et l'argument
ncol (3e par défaut) indique le nombre de colonnes.
> matrix(data = 1:12, nrow = 3, ncol = 4)

[,1] [,2] [,3] [,4]
[1,] 1 4 7 10
[2,] 2 5 8 11
[3,] 3 6 9 12
> matrix(1:12, 3, 4)
[,1] [,2] [,3] [,4]
[1,] 1 4 7 10
[2,] 2 5 8 11
[3,] 3 6 9 12
La syntaxe totale de la fonction matrix (http://stat.ethz.ch/R-manual/R-devel/library/base/htm

l/matrix.html) est la suivante :
matrix(data = NA, nrow = 1, ncol = 1, byrow = FALSE,
dimnames = NULL)
Le paramètre data est un vecteur contenant les éléments de la matrice.

Lorsque le vecteur contient
moins d'éléments que la matrice à construire, les données du vecteur sont utilisées plusieurs fois,
et lorsqu'il contient plus d'éléments, les éléments en trop sont ignorés.
La dimension de la matrice
est déterminée par nrow (nombre de lignes) et ncol (nombre de colonne).
Lorsque byrow vaut
TRUE, la matrice est complétée ligne par ligne, dans le cas contraire, colonne par colonne.
> a <- matrix (c(1,2,3,4), 2, 2, byrow=TRUE)
> a
[,1] [,2]
[1,] 1 2
[2,] 3 4
Pour initialiser une matrice nulle, on peut également utiliser rep() :
> n1 <- 3
> n2 <- 3
> a <- matrix (rep(0, n1*n2), n1, n2)
> a
[,1] [,2] [,3]
[1,] 0 0 0
[2,] 0 0 0
[3,] 0 0 0
Accès aux éléments d'une matrice
De même que pour les vecteurs, les indices vont de 1 à nrow et de 1 à ncol.
a[i, j] désigne l'élément de la ligne i et de la colonne j de la matrice a ;

a[i, ] désigne le vecteur correspondant à la i-ième ligne de la matrice a ;
a[, j] désigne le vecteur correspondant à la j-ième colonne de la matrice a ;
> a[2,1]
[1] 3
> a[1,]
[1] 1 2
> a[,1]
[1] 1 3
On peut également, pour les indices, utiliser des vecteurs d'indice, ou bien une matrice booléenne.
> a[c(1, 2), c(3, 4)]
[,1] [,2]
[1,] 7 10
[2,] 8 11
> indices <- a>5
> indices
[,1] [,2] [,3] [,4]
[1,] FALSE FALSE TRUE TRUE
[2,] FALSE FALSE TRUE TRUE
[3,] FALSE TRUE TRUE TRUE
> a[indices]
[1] 6 7 8 9 10 11 12
On remarque que la dernière solution renvoie un vecteur et non une matrice.
Enfin, on peut indexer une matrice par un seul indice ; R défile alors les colonnes de haut en bas,
et de gauche à droite :
> a
[,1] [,2] [,3] [,4]
[1,] 1 4 7 10
[2,] 2 5 8 11
[3,] 3 6 9 12
> a[4]
[1] 4
Le rapport entre l'indice unique ket la paire d'indices (i, j) est :
j <- k%/%nrow(a) + 1
i <- k%%nrow(a)
k = (j - 1)*nrow(a) + i
Arithmétique des matrices
Opérations terme à terme
Il est possible d'additionner +, soustraire -, multiplier * et diviser des matrices /. Toutes ces
opérations sont effectuées entre les coefficients correspondants des matrices. En particulier pour
la multiplication, il ne s'agit pas de la multiplication matricielle telle qu'elle est définie en
mathématiques, comme le montre l'exemple suivant.
Matrice a Matrice b
> a = matrix (c(1,2,3,4,5,6), 2, 3)

> b = matrix (c(5,1,3,4,1,0), 2, 3)
> a
> b
[,1] [,2] [,3]

[,1] [,2] [,3]
[1,] 1 3 5
[1,] 5 3 1
[2,] 2 4 6
[2,] 1 4 0
Opération Description Résultat
[,1] [,2] [,3]
a+b
Addition terme à terme [1,] 6 6 6
[2,] 3 8 6
[,1] [,2] [,3]
a-b
Soustraction terme à terme [1,] -4 0 4
[2,] 1 0 6
Multiplication terme à terme
a*b
[,1] [,2] [,3]
[1,] 5 9 5
[2,] 2 16 0
[,1] [,2] [,3]
a/b
Division terme à terme [1,] 0.2 1 5
[2,] 2.0 1 Inf
Opérations algébriques
Soient A et B deux matrices.
La multiplication matricielle s'obtient avec l'opérateur %*% :
A %*% B
Cette syntaxe permet également de multiplier un vecteur par une matrice.
Le déterminant s'obtient avec la commande determinant() :
determinant(A)
La transposition de la matrice A se fait avec
aperm(A)
Si A et B sont des matrices ligne (mais pas des vecteurs au sens de R), on peut donc calculer le
produit scalaire
A %*% aperm(B)
et si ce sont des matrices colonne, avec
aperm(A) %*% B
et ainsi, la norme d'une matrice ligne ou colonne est
sqrt(A %*% aperm(A))
# ou bien
sqrt(aperm(A) %*% A)
Si A est une matrice régulière (carrée inversible), on a son inverse avec
solve(A)
L'extraction des valeurs et vecteurs propres se fait avec
x = eigen(A)
x$values # valeurs propres
x$vectors # vecteurs propres
title=Programmer_en_R/Manipuler_les_matrices&oldid=636980 »
28/11/2021 00:54 Programmer en R/Les fonctions statistiques de base — Wikilivres
Moyenne, médiane, variance et écart-type
Nom des fonctions
R dispose de fonctions pour calculer les paramètres descriptifs d'une variable statistique :
mean (http://stat.ethz.ch/R-manual/R-devel/library/base/html/mean.html) : Calcul de la

moyenne
median (http://stat.ethz.ch/R-manual/R-patched/library/stats/html/median.html) : Calcul de la
médiane
sd (http://stat.ethz.ch/R-manual/R-devel/library/stats/html/sd.html) : Calcul de l'écart-type
(standard déviation en anglais)
var (http://stat.ethz.ch/R-manual/R-devel/library/stats/html/cor.html) : Calcul de la variance
La variance et l'écart-type correspondent a et
,
Attention : les fonctions dans R ne calculent pas directement la
variance et l'écart-type, mais leurs estimateurs sans biais : et
Ces fonctions ont une syntaxe similaire :
fonction (x, …)
La variable x désigne un vecteur contenant les données que l'on souhaite traiter.
Les données
consistent en des nombres entiers, réels ou complexes, le calcul étant également possible sur des
dates.
Ces fonctions disposent de paramètres dont la description complète est donnée dans la
documentation de R.
Exemples
Le plus fréquemment, x est un vecteur, c'est le cas de l'exemple ci-dessous.
> x <- c(1, 6, 3, 4, 9, 6)
> mean (x)
[1] 4.833333
https://fr.wikibooks.org/wiki/Programmer_en_R/Les_fonctions_statistiques_de_base 1/4
> median (x)
[1] 5
> var (x)
[1] 7.766667
> sd (x)
[1] 2.786874
La fonction median() ne peut pas être utilisée sur un data.frame. Pour les autres fonctions, voilà
ce que l'on obtient :
> df <- data.frame (A = c(1, 2, 7, 4), B = c(5, 2, 4, 1))
> mean (df)
A B
3.5 3.0
> var (df)
A B
A 7.0000000 -0.3333333
B -0.3333333 3.3333333
> sd (df)
A B
2.645751 1.825742
La moyenne a donc été calculée sur chacune des colonnes du data.frame, le résultat est un
vecteur, indexe par le nom des colonnes de df. Si m <- mean(df), on a alors m[1] = m['A'] = 3,5.
La fonction var() calcule la matrice de covariance des colonnes de df. Le résultat est une matrice
dont on accède aux différents coefficients soit par leur numéro de ligne et de colonne, soit par les
index 'A' et 'B'.
Pour l'écart-type, on obtient le vecteur correspondant à l'écart-type de chacune des colonnes de df.
Pour terminer, ces fonctions permettent également des calculs sur des matrices :
> m <- matrix (c(1, 3, 4, 5, 6, 7, 7, 8), 4, 2)
> m
[,1] [,2]
[1,] 1 6
[2,] 3 7
[3,] 4 7
[4,] 5 8
> mean (m)
[1] 5.125
> median (m)
[1] 5.5
> var (m)
[,1] [,2]
[1,] 2.916667 1.3333333
[2,] 1.333333 0.6666667
> sd (m)
[1] 1.7078251 0.8164966
La moyenne et la médiane ont été calculées sur l'ensemble des coefficients de la matrice.
La
fonction var() calcule la matrice de covariance, et la fonction sd() calcule le vecteur des écart-
type de chacune des colonne de m.
Que faire si des valeurs sont absentes ?
Le paramètre na.rm est un paramètre qui peut prendre les valeurs TRUE ou FALSE, par défaut sa
valeur est FALSE.
na.rm = TRUE : force le calcul en ne tenant compte que des valeurs présentes ;
na.rm = FALSE : interdit le calcul lorsque des valeurs sont absentes.
> x = c(1, 6, 3, NA, 9, 6)
> x
[1] 1 6 3 NA 9 6
> mean (x)
[1] NA
> mean (x, na.rm = TRUE)
[1] 5
> m = matrix (c(1, 3, 4, 5, 6, NA, 7, 8), 4, 2)
> m
[,1] [,2]
[1,] 1 6
[2,] 3 NA
[3,] 4 7
[4,] 5 8
> var (m, na.rm = TRUE)
[,1] [,2]
[1,] 4.333333 2
[2,] 2.000000 1
Le calcul mean (x) s'est avéré impossible, alors que la commande mean (x, na.rm = TRUE) a
calculé la moyenne des cinq nombres 1, 6, 3, 9, 6. Dans le cas de la matrice m, c'est toute la
deuxième ligne qui a été retirée comme on peut le vérifier :
> m = matrix (c(1, 4, 5, 6, 7, 8), 3, 2)
> m
[,1] [,2]
[1,] 1 6
[2,] 4 7
[3,] 5 8
> var (m)
[,1] [,2]
[1,] 4.333333 2
[2,] 2.000000 1
title=Programmer_en_R/Les_fonctions_statistiques_de_base&oldid=636981 »
28/11/2021 00:54 Programmer en R/Les loi de probabilités, ajustement et test — Wikilivres
Le logiciel R dispose d'une extension (package) dédiée aux statistiques, stats, qui est chargée par
défaut. Il contient les lois statistiques suivantes : lois bêta, binomiale, de Cauchy, χ2 (khi-deux, khi
carré), exponentielle, F de Fisher, gamma, géométrique, hypergéométrique, log-normale,
multinomiale, binomiale négative, normale, de Poisson, t de Student, uniforme, de Weibull, du
paradoxe des dates d'anniversaire, du rang signé de Wilcoxon, de Tukey et de la somme des rangs
de Wilcoxon.
Fonctions relatives aux lois de probabilité

Pour chacune de ces lois, R fournit, lorsqu'elle est définie, la densité de probabilité, la fonction de
répartition (probabilités cumulées), la fonction de probabilité inverse (quantiles) et un générateur
de nombres aléatoires suivant cette loi. Les noms des fonctions sont déterminés de manière
systématique.
Nom des fonctions liées aux lois de probabilité

Fonctions, préfixe
Loi, suffixe Densité de Fonction de Générateur

Quantiles
probabilité
répartition
aléatoire
q
d p r
bêta, beta dbeta pbeta qbeta rbeta
binomiale, binom dbinom pbinom qbinom rbinom
de Cauchy, cauchy dcauchy pcauchy qcauchy rcauchy
χ2, chisq dchisq pchisq qchisq rchisq
exponentielle, exp dexp pexp qexp rexp

F, f df pf qf rf
gamma, gamma dgamma pgamma qgamma rgamma
géométrique, geom dgeom pgeom qgeom rgeom
hypergéométrique,
dhyper phyper qhyper rhyper
hyper
log-normale, lnorm dlnorm plnorm qlnorm rlnorm
multinomiale,
dmultinorm pmultinorm qmultinorm rmultinorm
multinorm
binomiale négative,
dnbinom pnbinom qnbinom rnbinom
nbinom
normale, norm dnorm pnorm qnorm rnorm
de Poisson, pois dpois ppois qpois rpois
t de Student, t dt pt qt rt
uniforme, unif dunif punif qunif runif
de Weibull, weibull dweibull pweibull qweibull rweibull
Paramètres des fonctions
https://fr.wikibooks.org/wiki/Programmer_en_R/Les_loi_de_probabilités,_ajustement_et_test 1/4
Les paramètres des fonctions dépendent des paramètres des lois. Deux options sont utilisées de
manière générale :
log = TRUE ou log.p = TRUE : la probabilité est exprimée par son logarithme népérien
ln(p) ;
lower.tail = FALSE : la probabilité est exprimée par la probabilité complémentaire 1 – p.
Ces options ne sont illustrées que pour la loi normale. Nous donnons quelques exemples pour des
lois fréquemment utilisées.
Loi normale
Une loi normale admet deux paramètres : l'espérance (ou moyenne, mean) μ (mu) et l'écart type
(standard deviation) σ (sigma). On a donc :
dnorm(x) : densité de probabilité en x de la loi normale centrée réduite, φ(x) ;
dnorm(x, m, s) ou dnorm(x, mean = m, sd = s) : densité de probabilité en x de la loi

normale d'espérance m et d'écart type s ;
pnorm(x) : fonction de répartition en x de la loi normale centrée réduite, Φ(x) ;
pnorm(x, m, s) ou pnorm(x, mean = m, sd = s) : idem pour la loi normale d'espérance

m et d'écart type s ;
qnorm(p) : quantile de la probabilité p pour la loi normale centrée réduite, Φ–1(p) ;
qnorm(p, m, s) ou qnorm(p, mean = m, sd = s) : idem pour la loi normale d'espérance

m et d'écart type s ;
rnorm(n) : génération de n nombres aléatoires suivant la loi normale centrée réduite ;
rnorm(n, m, s) ou rnorm(n, mean = m, sd = s) : idem pour la loi normale d'espérance

m et d'écart type s.
Par ailleurs, ces fonctions admettent des options :
logarithme népérien de la probabilité : dnorm(x, mean = m, sd = s, log = TRUE) (=

ln(dnorm(x, m, s))), pnorm(x, mean = m, sd = s, log.p = TRUE) (= ln( pnorm(x, m,
s))), qnorm(p, mean = m, sd = s, log.p = TRUE) (= qnorm(exp(p), m, s)) ;
probabilité complémentaire : pnorm(x, mean = m, sd = s, lower.tail = FALSE) (= 1 –
pnorm(x, m, s)), qnorm(p, mean = m, sd = s, lower.tail = FALSE) (= qnorm(1 -
p, m, s)).
Loi uniforme
Une loi uniforme admet deux paramètres : le minimum a et le maximum b de l'intervalle de

définition. On a donc :
dunif(x) : densité de probabilité en x de la uniforme sur [0 ; 1] ;
dunif(x, a, b) ou dunif(x, min = a, max = b) : densité de probabilité en x de la loi

uniforme sur [a ; b] ;
…
Loi binomiale
Une loi binomiale admet deux paramètres : la taille de l'échantillon (size, nombre de tirages) n et
la probabilité de réussite de chaque épreuve, P. On a donc :
dbinom(k, n, P) ou dbinom(k, size = n, prob = P) : probabilité d'avoir k réussite

parmi n tirages ;
…
Loi exponentielle
Une loi exponentielle admet un paramètre : le taux (rate) λ (lambda). On a donc :
dexp(x, lambda) ou dexp(x, rate = lambda) : densité de probabilité en x de la loi

exponentielle de paramètre beta et lambda ;
…
Loi de Poisson
Une loi de Poisson admet un paramètre : son espérance λ (lambda). On a donc :
dpois(k, l) ou dpois(k, lambda = l) : densité de probabilité en k de la loi de Poisson

de paramètre l ;
…
Loi du khi-carré
Une loi du χ2 admet un paramètre : le nombre de degrés de liberté (degrees of freedom) k. On a

donc :
dchisq(x, k) ou dchisq(x, df = k) : densité de probabilité en x de la loi du χ2 à k

degrés de liberté ;
…
Les fonctions sont aussi définies pour les lois non-centrées ; on introduit alors le paramètre de
décentralisation (non-centering parameter) λ : dchisq(x, k, lambda) ou dchisq(x, df = k,
ncp = lambda).
Loi t de Student
Une loi t de Student admet un paramètre : le nombre de degrés de liberté (degree of freedom) k.
On a donc :
dt(x, k) ou dt(x, df = k) : densité de probabilité en x de la loi t de Student à k degrés

de liberté ;
…
décentralisation μ : dt(x, k, mu) ou dt(x, df = k, ncp = mu).
Loi F (de Fisher)
Une loi F admet deux paramètres : les degrés de liberté (degrees of freedom) ν1 et ν2 (nu). On a
donc :
df(x, nu1, nu2) ou df(x, df1 = nu1, df2 = nu2) : densité de probabilité en x de la loi
F à ν1 et ν2 degrés de liberté ;
…
décentralisation λ : df(x, nu1, nu2, lambda) ou df(x, df1 = nu1, df2 = nu2, ncp =
lambda).
Loi de Weibull
Une loi de Weibull admet deux paramètres : le paramètre de forme (shape) β (bêta, parfois noté k)
et le paramètre d'échelle (scale) λ (lambda). On a donc :
dweibull(x, beta, lambda) ou dweibull(x, shape = beta, scale = lambda) :

densité de probabilité en x de la loi de Weibull de paramètres beta et lambda ;
…
title=Programmer_en_R/Les_loi_de_probabilités,_ajustement_et_test&oldid=654478 »
La dernière modification de cette page a été faite le 1 mars 2021 à 12:59.

Learning R Programming Language With WikiBook (PDF) (FR)

Transféré par

Droits d'auteur :

Formats disponibles

Learning R Programming Language With WikiBook (PDF) (FR)

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Learning R Programming Language With WikiBook (PDF) (FR)

Transféré par

Droits d'auteur :

Formats disponibles

28/11/2021 00:43 Programmer en R — Wikilivres

R est un langage de programmation dédié aux statistiques.

Table des matières

Ce wikilivre porte l'indice CDU

La dernière modification de cette page a été faite le 5 décembre 2020 à 13:59.

Voyez les termes d’utilisation pour plus de détails.

Cette section constitue une rapide introduction à R.

Manipuler des nombres

> "ceci est une chaîne de caractère"

[1] "ceci est une chaîne de caractère"

Enregistrer des données

On peut ensuite afficher la valeur :

On peut aussi utiliser cet objet dans d'autres calculs :

La fonction c() permet de construire un vecteur.

> prix <- c(1.90, 3.50, 14.90)

[1] 1.9 3.5 14.9

> fruit <- c("pomme", "poire", "fraise")

[1] "pomme" "poire" "fraise"

On peut accéder à un élément du vecteur en utilisant les crochets et le numéro de l'élément.

> fruit <- c("pomme", "poire", "fraise")

[1] "pomme" "poire"

[1] "pomme" "poire" "fraise"

[1] "pomme" "fraise"

> A <- matrix(c(1, 2, 3, 4, 5, 6), nrow=2)

[,1] [,2] [,3]

> B <- array(1:6, dim = c(3, 2))

On peut aussi assembler des vecteurs-ligne (row bind) :

> A <- rbind(c(1, 3, 5), c(2, 4, 6)); print(A)

[,1] [,2] [,3]

Les opérations algébriques élémentaires sont les suivantes :

> A %*% B # produit matriciel

> aperm(A, c(2, 1)) # transposition

> A*A # produit terme à terme

[,1] [,2] [,3]

> table_fruits <- data.frame(

+ fruit = c("pomme", "poire", "fraise"),

+ prix = c(1.90, 3.50, 14.90)

Pour accéder à la colonne prix, on peut utiliser :

utiliser la syntaxe des crochets et indiquer le nom de la colonne après la virgule

[1] 1.9 3.5 14.9

[1] 1.9 3.5 14.9

[1] 1.9 3.5 14.9

Pour accéder à la deuxième ligne, on utilise la syntaxe des crochets :

ou bien avec le point d'interrogation

Installer et charger une librairie

> 5 %>% exp()

> 5 %>% exp() %>% log()

La dernière modification de cette page a été faite le 20 avril 2020 à 13:50.

Voyez les termes d’utilisation pour plus de détails.

$ sudo apt-get install r-base

La dernière modification de cette page a été faite le 20 avril 2020 à 13:57.

Voyez les termes d’utilisation pour plus de détails.

Console interactive de commande en langage R.

RStudio sous Ubuntu.

Un notebook permet de combiner du texte et du code dans un même document.

Au préalable, il faut avoir installé Jupyter [2]

$ pip3 install jupyter

install.packages(c('repr', 'IRdisplay', 'crayon', 'pbdZMQ', 'devtools'))

IRkernel::installspec() # to register the kernel in the current R