Exercices de programmation R

Marie Laure Delignette-Muller

2024-01-10

Contents
Concepts de base 2
Création d’un objet R simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
Création d’un vecteur ou d’une matrice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Indexation d’un vecteur ou d’une matrice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

Les jeux de données 7

Création d’un jeu de données directement dans R . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Indexation d’un jeu de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Ajout de colonnes calculées à partir des colonnes préexistantes . . . . . . . . . . . . . . . . . . . . . . 8
Les facteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Importation et exploration rapide d’un jeu de données . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

Manipulation de données 9
Importation d’un jeu de données plus complexe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Recodage simple d’une variable numérique en facteur . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Modification des noms et de l’ordre des modalités d’un facteur et sélection de lignes . . . . . . . . . . 10
Transformation d’une variable quantitative en variable qualitative par définition de classes . . . . . . . 10
Création d’une nouvelle variable quantitative par calcul . . . . . . . . . . . . . . . . . . . . . . . . . . 11

Manipulation de données (suite OPTIONNELLE pour les plus rapides) 11

Création des variables Revenu et RevenuF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
Recodage des nombres de chiens et nombres de chats . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

Automatisation des calculs 12

Structures conditionnelles if et itératives for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Ecriture d’une fonction et application d’une fonction par groupe à l’aide de la fonction tapply() . . . 13

Sauvegarde du jeu de données augmenté 13

Visualisation de données avec ggplot2 14

1
Concepts de base
A FAIRE en début, en cours et en fin de session Rstudio

• En début de session on ouvre un script R (ou .rmd si on veut d’emblée intégrer le script dans un rapport
d’analyse), et si c’est un nouveau script on le sauve d’emblée avec l’extension .R (ou .Rmd pour un
rapport d’analyse), dans le même dossier que celui où sont les fichiers de données (pas obligatoire mais plus
simple).
• On change le répertoire de travail (Onglet Session, Set Working Directory) et on le définit au répertoire
où se trouve le script et les données (option To Source File location).
• On sauve le script très régulièrement !!!
• En fin de session Rstudio vous demande si vous voulez sauver l’espace de travail (workspace). Il
est fortement conseillé de toujours refuser pour éviter des problèmes (sauf cas très exceptionnels qui ne
devraient pas vous concerner de suite).

A SAVOIR avant de commencer :

• R est sensible à la casse (majuscule / minuscule)

• Dans un code R , tout ce qui se trouve à droite du signe # est considéré comme un commentaire, donc non
interprété comme du code (mais bien utile pour comprendre son code).
• Le séparateur de décimale dans R est le point ..
• Le symbole <- est utilisé pour affecter une valeur à un objet. Mieux vaut ne pas le remplacer par le symbole
= même si souvent ça fonctionne (mais pas toujours !). Le symbole = est à réserver pour la définition des
valeurs des arguments dans l’appel à une fonction.
• Nommez les objets R avec des noms parlants (pas trop courts donc) mais pas trop longs non plus.
• Evitez de donner des noms qui sont susceptibles de correspondre à des noms de fonctions R (ex. : median)
• Ne commencez pas le nom d’un objet par un chiffre.
• Evitez les accents, les espaces et les caractères spéciaux dans les noms des objets R ainsi que dans les
fichiers de données que vous allez importer dans R (donc y penser bien en amont dès la saisie des données
dans un tableur par exemple). Les seuls caractères spéciaux conseillés dans les noms d’objets, tant qu’ils
ne sont pas en début de nom, sont _ et . (ex. : animal_prefere).
• Dans les données, codez les variables quantitatives par des nombres (donc pas ‘J1, J3, J10 par ex.) et les
variables qualitatives par des chaînes de caractères (donc pas 1 pour les mâles et 0 pour les femelles par
ex.). Cela vous évitera une étape de recodage dans R.
• Les données manquantes doivent être codées NA (pas de cellule vide dans un tableau de données que l’on
souhaite importer dans R).

Quelques liens qui vous seront sans doute utiles :

Pour l’utilisation de R

• la “cheat sheet” de la base de R : https://iqss.github.io/dss-workshops/R/Rintro/base-r-cheat-sheet.pdf

• la carte de référence de R en français : https://www.apmep.fr/IMG/pdf/R_RefCard.pdf
• la carte de référence de R (version 2 plus moderne) en anglais : https://cran.r-project.org/doc/contrib/
Baggott-refcard-v2.pdf
• Le “cookbook” de R : http://www.cookbook-r.com/

Pour l’utilisation de rmarkdown pour inclure le code R (et les sorties) dans un rapport d’analyse

• le “cookbook” de rmarkdown : https://bookdown.org/yihui/rmarkdown-cookbook/

• la “cheat sheet” de rmardown : https://rstudio.github.io/cheatsheets/rmarkdown.pdf

2
Pour faire des graphes avec ggplot2

• le “cookbook” de ggplot2 : https://r-graphics.org/

• la “cheat sheet” de ggplot2 : https://rstudio.github.io/cheatsheets/data-visualization.pdf

Création d’un objet R simple

UTILISATION du signe d’affectation <-, des fonctions class(), rm(), print(), paste(),
is.numeric(), is.character(), is.logical() et as.numeric(), as.character(),
as.logical() et des opérateurs mathématiques et logiques (ET : &, OU : |, EGAL:
==, DIFFERENT DE !=, NON : !, SUPERIEUR >, SUPERIEUR ou EGAL>=, etc.),

Pour vous approprier les bases, exécutez chaque ligne de code une à une en prenant le temps d’examiner ce qui
est produit.
Pour la plupart des exercices, nous vous indiquons le nom des fonctions à utiliser. Ayez le réflexe à chaque fois
d’aller voir l’aide en ligne des fonctions que vous ne connaissez encore pas bien en tapant ?nom_de_la_fonction.

# --- les nombres (`numeric`) ---

age <- 45 # affectation d'une valeur à un objet R
age # pour voir l'objet
print(age) # une autre façon de voir l'objet
class(age) # pour connaître la classe de l'objet

rm(age) # pour effacer un objet de l'espace de travail

# regarder l'effet de cette commande dans onglet Environment en haut à droite de Rstudio

(age <- 45) # pour faire l'affectation et voir l'objet en même temps
(age_en_mois <- age * 12)
(age_au_carre <- ageˆ2)

# --- les chaînes de caractères (`character`) ---

genre <- "masculin"
pays <- "Autriche"
class(genre)

# collage de chaîne de caractères sans séparateur

(phrase <- paste("Ce répondant est de genre ", genre, ".", sep = ""))

# --- les booléens (`logical`) ---

(jeune <- age < 30)
class(jeune)

# utilisation des opérateurs logiques

(homme_jeune <- (age < 30) & (genre == "masculin"))
# autres façons d'écrire la même chose
(homme_jeune <- (age < 30) & (genre != "feminin"))
(homme_jeune <- !(age >= 30) & (genre == "masculin"))
(homme_jeune <- !((age >= 30) | (genre == "feminin")))

# Vérification de la classe et changement de classe d'un objet

is.numeric(age)
is.numeric(jeune)

3
(jeune_num <- as.numeric(jeune))
is.numeric(jeune_num)

EXERCICE pour appliquer ce que vous avez découvert précédemment :

1. Créez une phrase sous forme d’une chaîne de caractères avec la fonction paste() en utilisant les deux
objets créés (age et pays) pour indiquer l’âge et le pays du répondant, et affichez-la à l’écran pour vérifier
le résultat.
2. Créez un booléen indiquant si le répondant est autrichien d’au moins 18 ans et vérifier sa valeur bien sûr.
3. Créez un booléen indiquant si le répondant a moins de 16 ans ou plus de 70 ans.
4. Calculez l’âge du répondant en log en utilisant la fonction log(). Celle-ci donne-t-elle le logarithme népérien
ou décimal de l’âge ? Trouvez à l’aide sur la fonction log() (en tapant ?log) comment on obtient l’autre
log.

Création d’un vecteur ou d’une matrice

UTILISATION du calcul vectorisé et des fonctions c(), rep(), seq(), matrix(), rbind(),
cbind(). rownames(), colnames(), is.vector(), is.matrix(), length(), dim(), nrow(),
ncol().

Un vecteur est un objet R utilisé notamment pour stocker toutes les valeurs d’une variable en statistique. Il est à
une dimension et ne contient que des éléments de même type. En statistique il permettra par exemple de stocker
les valeurs d’une variable quantitative (vecteur de nombres), ou d’une variable qualitative (vecteur de chaînes de
caractères). Une matrice, c’est la même chose en dimension 2, toujours ne contenant que des éléments de même
type.
On peut créer un vecteur, par exemple,

• avec la fonction c() pour concaténer plusieurs valeurs,

• avec la fonction rep()pour répéter plusieurs fois une même valeur,
• avec la fonction seq() pour générer une séquence régulière de valeurs,
• ou par calcul à partir d’autres vecteurs créés auparavant. Le calcul est en effet vectorisé par défaut dans R,
ce qui veut dire que si l’on écrit un calcul impliquant un ou plusieurs vecteurs, il fait automatiquement le
calcul pour tous les éléments du (ou des) vecteur(s) impliqué(s), élément par élément (i.e. ligne à ligne).

Pour bien comprendre l’usage de ces fonctionnalités, exécutez chaque ligne de code une à une en prenant le temps
d’examiner ce qui est produit.

# Création de vecteurs avec c()

(Age <- c(71, 29, 45, 32, 81))
is.vector(Age)
class(Age) # donne le type du vecteur
length(Age)

Pays <- c("Autriche", "Danemark", "Danemark", "UK", "Autriche")

class(Pays)

Genre <- c("feminin", "feminin", "masculin", "masculin", "feminin")

# Création d'un vecteur avec rep()

(Annee <- rep(2023, times = 5))

4
# Création de séquences régulières
(Numero <- 1:5)
(Numero <- seq(from = 1, to = 5, by = 1))
(Numero10en10 <- seq(from = 10, to = 60, by = 10))

# Ajout de valeurs
(Agecomplete <- c(Age, 14, 17))
class(Agecomplete)
length(Agecomplete)

# Que se passe-t-il si on concatène des valeurs qui ne sont pas du même type ?
(Agecomplete2 <- c(Age, "mineur", "mineur"))
class(Agecomplete2)

# Calcul vectorisé
Ageˆ2
Annee - Age
(PaysETGenre <- paste(Pays, Genre, sep = "."))
(Majeur <- Agecomplete >= 18)
class(Majeur)

EXERCICE pour appliquer ce que vous avez découvert précédemment (en vérifiant le résultat
à chaque fois bien sûr) :

1. Créez un vecteur de type chaîne de caractères avec la fonction paste() en utilisant les deux vecteurs créés
(Genre et Age) pour indiquer le genre et l’âge de chaque répondant, avec comme séparateur _.
2. Créez un vecteur de type booléen (logical) indiquant si le répondant est autrichien ou du Royaume Uni
et a au moins 50 ans.
3. Créez un vecteur de type numérique codant avec un 1 les femmes et un 0 les garçons en utilisant le calcul
vectorisé avec les opérateurs logiques et la fonction as.numeric().

Pour créer une matrice on peut par exemple utiliser la fonction matrix() ou les fonctions rbind() et cbind()
qui permettent de juxtaposer des vecteurs de même type respectivement par ligne ou colonne. Voici quelques
exemples à explorer par vous mêmes.

# Création d'une matrice par remplissage par ligne

(Matrice1 <- matrix(c(1, 2, 3, 4, 11, 12, 13, 14), byrow = TRUE, ncol = 4))
class(Matrice1)
is.matrix(Matrice1)
is.vector(Matrice1)
dim(Matrice1)
nrow(Matrice1)
ncol(Matrice1)

# en changeant le nombre de colonnes

(Matrice2 <- matrix(c(1, 2, 3, 4, 11, 12, 13, 14), byrow = TRUE, ncol = 2))

# Création d'une matrice par remplissage par colonne

(Matrice3 <- matrix(c(1, 2, 3, 4, 11, 12, 13, 14), byrow = FALSE, ncol = 2))

# Création de noms de colonnes

colnames(Matrice3) <-

5
c("i", "10+i")
Matrice3

EXERCICE pour manipuler les matrices (en vérifiant le résultat à chaque fois bien sûr) :

1. Créez une nouvelle matrice de la même dimension que Matrice3 ne contenant que des valeurs à 100.
2. Créez une nouvelle matrice comme la somme de Matrice3 et de celle que vous venez de créer
3. Utilisez la fonction colnames() pour changer les noms de colonnes de cette matrice “100+i” et “110+i”.
4. En OPTIONNEL pour les plus rapides, créez une matrice sur le même format mais pour i allant de 1 à 9,
en utilisant 1:9, nommez ces colonnes “100+i” et “110+i” et ses lignes “ligne_i” avec i allant de 1 à 9.
Vous pouvez explorer plusieurs solutions.

Indexation d’un vecteur ou d’une matrice

On peut indexer un vecteur (ou une matrice) par position, en indiquant le numéro de ligne (et de colonne pour
une matrice) entre crochets (séparés par une virgule dans le cas d’une matrice), par nom (si les lignes - resp. les
colonnes - sont nommées), ou par condition logique. Pour bien comprendre comment cela fonctionne explorez
les codes suivants.

# Indexation par position d'un vecteur

Age # juste pour avoir en tête toutes les valeurs
Age[1]
Age[2:4]
Age[length(Age)]
Age[c(-1, -3)] # pour enlever des éléments

## Indexation par condition d'un vecteur

Age[Age > 30]
Age[Genre == "masculin"]

Pour une matrice on indique toujours entre les crochets ce qui correspond aux lignes, une virgule, puis ce qui
correspond aux colonnes. La virgule doit être mise même si on ne fait une sélection que sur les lignes ou que sur
les colonnes. Explorez les exemples ci-dessous.

# création de Matrice6 pour ceux qui ne l'auraient pas créée auparavant

Matrice6 <- matrix(rep(100, times = 18) + c(1:9, 11:19), ncol = 2, byrow = FALSE)
colnames(Matrice6) <- c("100+i", "110+i")
rownames(Matrice6) <- paste("ligne", 1:9, sep = "_")
Matrice6

# Indexation par position d'une matrice

Matrice6[3, 2] # toujours [numéro de ligne, numéro de colonne]
Matrice6[1:5, ]
Matrice6[ , 2]

## Indexation par nom

Matrice6["ligne_1", ]
Matrice6["ligne_1", "110+i"]

6
Les jeux de données

Création d’un jeu de données directement dans R

UTILISATION des fonctions data.frame(), str(), is.data.frame(), as.data.frame()

Un jeu de données est un objet R de dimension 2, comme une matrice, mais à la différence d’une matrice il ne
contient pas forcément des éléments tous du même type. Il est composé de vecteurs colonnes qui peuvent
être de types différents. Un jeu de données est une juxtaposition de vecteurs dans lesquels sont stockées en
colonne les valeurs de différentes variables (qualitatives ou quantitatives), chaque ligne correspondant aux valeurs
des ces variables pour un même individu, ou plus généralement une même observation. Ci-dessous nous allons
créer un petit jeu de données “jouet” à partir des vecteur créés précédemment et utiliser quelques fonctions.
Explorez ce code.

# Création d'un jeu de données à partir de vecteurs

(d_jouet <- data.frame(age = Age, genre = Genre, pays = Pays))
class(d_jouet)
str(d_jouet) # structure du jeu de données
is.data.frame(d_jouet)

# Création d'un jeu de données à partir d'une matrice

# dans ce cas le jeu de données ne contiendra soit que des variables quantitatives
# soit que des variables qualitatives
is.data.frame(Matrice6)
(d_matrice6 <- as.data.frame(Matrice6))
str(d_matrice6)

Indexation d’un jeu de données

La façon la plus courante de sélectionner une colonne (donc une variable) d’un jeu de données est d’utiliser le nom
du jeu de données et d’y accoler $ suivi du nom de la variable, comme ci-dessous, mais on peut aussi l’indexer de
la même façon qu’une matrice pour sélectionner ligne(s) ou colonne(s). Testez les lignes de code ci-dessous pour
bien comprendre.

# Sélection d'une colonne (variable)

d_jouet$age
d_jouet$pays
d_jouet[, 2]

# Sélection de lignes
d_jouet[2:4, ]
d_jouet[d_jouet$age > 30, ]

# Sélection de colonnes par noms

d_jouet[, c("age", "pays")]

# Sélection sur lignes et colonnes

d_jouet[d_jouet$age > 30, ]$pays

7
Ajout de colonnes calculées à partir des colonnes préexistantes

Il est assez fréquent, quand on manipule des données, que l’on souhaite ajouter des variables calculées à partir
des colonnes de base (i.e. des données dites brutes), et il vaut bien mieux le fare dans R, que dans le tableur
(pour des raisons de traçabilité notamment). Pour créer une nouvelle variable dans le jeu de données, il suffit de
lui donner comme nom dans l’affection le nom du jeu de données suivi de $ suivi du nom que l’on veut donner à
la cette variable, comme ci-dessous :

d_jouet$age_log_10 <- log10(d_jouet$age)

d_jouet$pays_genre <- paste(d_jouet$pays, d_jouet$genre, sep = "_")
d_jouet$au_moins_50ans <- d_jouet$age >= 50
d_jouet

Les facteurs

UTILISATION des fonctions is.factor(), as.factor(), factor(), levels()

Pour que R considère les vecteurs de chaînes de caractères (type char) comme des variables qualitatives (type
factor), il faut les tranformer en facteurs. Ensuite il est souvent utile de modifier l’ordre des modalités d’un
facteur (par défaut il les ordonne par ordre alphabétique) et/ou de changer le nom des modalités. Découvrez
ces fonctionalités en testant le code ci-dessous.

# Transformation en facteur
class(d_jouet$pays)
d_jouet$pays <- as.factor(d_jouet$pays)
class(d_jouet$pays)
levels(d_jouet$pays)

# Changement des noms des modalités

levels(d_jouet$pays) <- c("Autriche", "Danemark", "Royaume-Uni")

# Changement de l'ordre des modalités

d_jouet$pays <- factor(d_jouet$pays, levels = c("Danemark", "Royaume-Uni", "Autriche"))
levels(d_jouet$pays)

Importation et exploration rapide d’un jeu de données

UTILISATION des fonctions read.table(), str(), head(), nrow(), dim(d), summary().

Généralement les jeux de données ne sont pas créés directement dans R mais importés par exemple à partir d’un
fichier texte exporté depuis un tableur. Avant d’importer un fichier contenant le jeu de données à importer, il est
important de savoir :

• s’il comporte ou non une en-tête (première ligne qui correspond aux noms des variables, pour définir
l’argument header de la fonction d’import),
• quel séparateur de colonnes a été utilisé (le point virgule ";", l’espace" ", la tabulation "\t", . . . , pour
définir l’argument sep de la fonction d’import),
• quel séparateur de décimales a été utilisé, pour définir l’argument dec de la fonction d’import. (AT-
TENTION, dans R le point . est utilisé, alors que sur la plupart des ordinateurs paramétrés en France, la
virgule ", " est utilisée. Il faudra donc indiquer dec = "," pour importer correctement un fichier venant
d’un tel ordinateur paramétré en français pour le séparateur de décimales).

8
Pour importer des données à partir d’un fichier .txt exporté classiquement avec comme séparateur de colonnes la
tabulation, nous utiliserons la fonction read.table() avec ses arguments header = TRUE si le fichier comporte
une en-tête, et stringsAsFactors = TRUE pour que les vecteurs de chaînes de caractères soient automatique-
ment transformés en facteurs.
Importez et explorez un jeu de données qui nous servira plus tard à l’aide des lignes de codes suivantes :

dENQ <- read.table("ENQ9697.txt", header = TRUE, stringsAsFactors = TRUE)

str(dENQ)
head(dENQ)
nrow(dENQ)
dim(dENQ)
summary(dENQ)

Manipulation de données

Importation d’un jeu de données plus complexe

UTILISATION des fonctions read.table(), str(), head(), nrow(), dim(d), summary(),

is.na(), complete.cases() et sum().

Pour illustrer les manipulations classiques de jeux de données, nous allons travailler sur des données réelles,
déposées sur Zenodo par les auteurs de l’article suivant :
Sandøe, P., Palmer, C., Corr, S. A., Springer, S., & Lund, T. B. (2023). Do people really care less about their
cats than about their dogs? A comparative study in three European countries. Frontiers in Veterinary Science,
10, 1237547. https:// www.ncbi.nlm.nih.gov/ pmc/ articles/ PMC10625900/ pdf/ fvets-10-1237547.pdf
Vous utiliserez le fichier Excel Sandoee_et_al-Frontiers_2023_v2_numeric.xls, récupéré sur zenodo, auquel j’ai
ajouté deux feuilles pour vous simplifier la tâche, l’une nommée data4R dans lequel on a fait une sélection des
colonnes du premier, colonnes que j’ai renommées de façon plus explicite (à partir du matériel supplémentaire
de l’article), l’autre nommée data4R_withNA dans lequel j’ai remplacé toutes les cellules vides par des NA pour
indiquer qu’il s’agit de données manquantes.

1. Sauvez la feuille data4R depuis Excel en format Texte (séparateur : tabulation), et tentez de l’importer
dans R avec la ligne de code suivante puis analysez le message d’erreur qui devrait vous apparaître.

d <- read.table("Sandoe2023_sansNA.txt", stringsAsFactors = TRUE, header = TRUE)

2. Ensuite utilisez la feuille dans laquelle on a remplacé les cellules vides par des NA pour importer le jeu de
données de la même façon, mais sans message d’erreur cette fois-ci.
3. Explorez les données importées (noms des variables, types des variables, nombre de lignes, . . . ) à l’aide des
fonctions str(), head(), nrow(), dim(d) et summary(). Listez quelques raisons pour lesquels un petit
travail de recodage va être nécessaire avant d’analyser ces données.
4. En OPTIONNEL pour les plus rapides, pour savoir si on a une information sur les revenus de chaque
répondant, calculez combien il y a de lignes sans données manquantes respectivement dans les colonnes
INCOME_AT, INCOME_DK, INCOME_UK et vérifiez que la somme correspond au nombre total de répon-
dants. Utilisez pour cela les fonctions is.na(), l’opérateur logique ! et la fonction sum().
5. Ensuite, toujours en OPTIONNEL, calculez combien il y a de lignes sans aucune donnée manquante (toutes
colonnes prises en compte expecté celles sur le revenu) en utilisant en plus la fonction complete.cases().

9
Recodage simple d’une variable numérique en facteur

UTILISATION des fonctions class(), as.factor(), levels(), factor() et table().

Dans ce jeu de données le pays (colonne Country) a été codé 1 pour l’Autriche, 2 pour le Danemark et 3 pour le
Royaume Uni, dans la variable Country. Nous allons créer dans le même jeu de données une nouvelle variable que
l’on appelera “Pays” et qui sera définie comme un facteur, avec comme modalités “Danemark”, “Autriche” et
“UK”, dans cet ordre. Nous calulerons aussi les effectifs de répondants dans chaque pays à l’aide de la fonction
table().
Faites tournez le code ci-dessous en regardant les objets créés pour bien comprendre ce que fait chaque instruction.

class(d$Country)
d$Pays <- as.factor(d$Country)
class(d$Pays)
levels(d$Pays)
levels(d$Pays) <- c("Autriche", "Danemark", "UK")
table(d$Pays) # pour vérifier la cohérence avec la table 2 de l'article

Modification des noms et de l’ordre des modalités d’un facteur et sélection de lignes

UTILISATION des fonctions subset(), class(), as.factor(), levels(), factor() et

table().

1. Le genre (colonne Gender) a été codé numériquement en 1 pour les hommes, 2 pour les femmes, 3 pour
les non genrés et 4 pour ceux qui ne voulaient pas donner leur genre. Créez une variable Genre à partir
de Gender, qui soit un facteur, de modalités “femme”, “homme”, “non genre” et “sans reponse”, dans cet
ordre.
2. Les auteurs de l’article avaient choisi d’exclure les données correspondant aux deux dernières catégories qui
étaient en faible nombre. On fera de même. Utilisez la fonction subset() pour créer un nouveau jeu de
données ds uniquement avec les lignes correspondant aux modalités 3 et 4 du genre. Vérifiez la cohérence
des résultats obtenus avec la table 2 de l’article en tapant table(d$Genre, d$Pays).
3. En OPTIONNEL pour les plus rapides, Refaites une table des effectifs des modalités du Genre à partir du
sous jeu de données. Que constatez-vous. Réappliquez la fonction factor() à la variable dans ce nouveau
jeu de données et refaites la table. Que constatez-vous ?

Dans la suite nous continuerons à travailler sur le jeu de données complet d et non sur la sélection faite
précédemment ds.

Transformation d’une variable quantitative en variable qualitative par définition de

classes

UTILISATION des fonctions min(), max() (et de leur argument na.rm), which(), table()
et cut().

Dans le jeu de données, la variable Age donne l’âge du répondant en années. Dans l’article l’âge semble être
manipulé sous forme d’une variable qualitative à 5 modalités, correspondant aux classes 18-29 ans, 30-39 ans,
40-49 ans, 50-59 ans et plus de 60 ans.

1. Créez une nouvelle variable qualitative que vous nommerez AgeF à l’aide de ce découpage en 5 classes, en
utilisant la fonction cut(). En amont calculez le valeurs min et max de l’âge des répondants, et gérez le
problème mis en évidence en remplaçant les valeurs irréalistes par des valeurs manquantes (NA).

10
 2. En OPTIONNEL pour les plus rapides, vérifiez la cohérence des résultats obtenus avec la table 2 de l’article
en tapant table(d$AgeF, d$Pays) et essayez de comprendre d’où viennent les différences observées (pour
ma part je n’y suis pas arrivée).

Création d’une nouvelle variable quantitative par calcul

UTILISATION de la vectorisation des calculs, de la fonction scale() et des fonctions mean()

et sd() avec leur argument na.rm .

Pour le cas où l’on voudrait utiliser ultérieurement l’âge en tant que variable quantitative, mais en le centrant
(i.e. enlevant l’âge moyen à chaque valeur) et en le réduisant (i.e. le divisant par son écart type), créez la variable
quantitative nommée AgeCR à l’aide de la fonction scale(). Vérifiez que cela a bien fonctionné en calculant la
moyenne et l’écart type de cette nouvelle variable.

Manipulation de données (suite OPTIONNELLE pour les plus rapides)

Création des variables Revenu et RevenuF

UTILISATION de l’indexation d’un jeu de données par un vecteur de noms de colonnes, des
fonctions summary() et rowSums() et de son argument na.rm.

Les auteurs de l’article ont fait trois colonnes nommées INCOME_AT (pour les revenus des australiens), IN-
COME_DK (pour les revenus des danois) et INCOME_UK (pour les revenus des anglais). Ils ont codé le revenu
par un score de 1 à 13 défini à partir de la classe d’appartenance de chaque revenu, définies pour chaque pays.
Les scores de 1 à 11 correspondent à des revenus croissants, la classe 12 à (préfère ne pas répondre) et la classe
13 à “je ne sais pas”.

1. Comparez les distributions des revenus dans les 3 pays en appliquant la fonction summary() à un sous jeu
de données contenant uniquement les trois colonnes INCOME_xx.
2. Créez dans d une colonne unique intitulée “Revenu” et contenant avec les revenus des tous les participants
à l’enquête, en utilisant la fonction rowSums() avec son argument na.rm. Vérifiez notamment à l’aide de
la fonction summary() que votre code a bien fonctionné.
3. Dans l’article le revenu est manipulé sous la forme d’une variable qualitative à 3 modalités, “revenu_haut”,
“revenu_bas”, “revenu_inconnu”. Créez une telle variable, nommée RevenuF, sachant que pour le Royaume-
Uni et l’Autriche le revenu est considéré comme bas s’il est inférieur ou égal à 3 dans codage original, mais
que pour le Danemark il est considéré comme bas s’il est inférieur ou égal à 5. Une façon de faire est
de créer à l’aide de la fonction factor() un facteur défini avec ces 3 modalités, rempli uniquement avec
des “revenu_inconnu”, puis de remplacer les valeurs qui doivent être à “revenu_bas” et “revenu_haut” en
fonction des valeurs de
“INCOME_AT”, “INCOME_DK” et “INCOME_UK”. Vérifiez la cohérence des résultats obtenus avec la
table 2 de l’article en tapant table(d$RevenuF, d$Pays).

Recodage des nombres de chiens et nombres de chats

Les colonnes nb_of_dogs et nb_of_cats codent pour le nombre de chiens et le nombre de chats, mais avec un
code un peu particulier. 1 correspond à 0, 2 à 1, 3 à 2, 4 à 3, 5 à 4 et 6 à plus de 4 chiens (resp. chats).

1. Définissez de nouvelles variables qualitatives Nchiens et Nchats sous forme de facteurs codant pour ces
variables, avec des noms de modalités plus explicites.

11
 2. Créez ensuite des variables Proprio_Chien et Proprio_Chat indiquant TRUE selon que le répondant est ou
non propriétaire de chien(s) (resp. chat(s)).
3. Créez une variable ChatChien à partir des deux précédentes, avec comme modalités “chien”, “chat”,
“chienETchat” ou “NIchienNIchat” (dans cet ordre) suivant que le répondant a seulement un ou des chiens,
seulement un ou des chats, les deux, ou ni l’un ni l’autre. On peut par exemple commencer par créer un
facteur rempli de NA avec la fonction rep() et la remplir au fur et à mesure pour chaque modalité.
4. Faites une table à deux entrées avec ChatChien et Pays pour vérifier la cohérence avec la table 1 de
l’article.

Automatisation des calculs

Structures conditionnelles if et itératives for

Afin de comprendre comment on utilise les structures conditionnelles et itératives, testez le code suivant.

# Utilisation de la boucle for

for (i in 1:5){
print(paste("Itération", i, sep = " "))
}

# Utilisation d'une condition if

valeur <- 40
if (valeur > 50){
print("OK")
} else {
print("KO")
}

# Boucle contenant une condition

valeurs <- c(12, 40, 45, 52, 67, 78)
for (i in 1:length(valeurs)){
if (valeurs[i] > 50){
print("OK")
} else {
print("KO")
}
}

Maintenant que vous avez compris comme cela fonctionne, nous appliquer ces structures de contrôle sur notre
jeu de données. Si vous ne l’avez pas déjà importé vous pouvez le faire avec la commande ci-dessous :

d <- read.table("Sandoe2023.txt", stringsAsFactors = TRUE, header = TRUE)

Le score d’attachement (LAPS - Lexingto attachment to pets scale) a été évalué pour chaque propriétaire, à partir
de 23 questions relatives à son attachement à son animal favori (Favorite_species). Cette dernière variable a été
codée en 1 pour “dog”, 2 pour “cat”, et de 3 à 9 pour les autres espèces.

1. Appliquez la fonction table() à la variable Favorite_species pour voir ce qu’elle contient.

2. Faites une nouvelle colonne Animal_favori que vous coderez en “chien”, “chat”, “autre”. Pour vous entraîner
à utiliser les structures conditionnelles et de boucle, faites cela en créant une nouvelle colonne de type facteur
(avec factor()), en indiquant au départ juste ses modalités dans l’ordre “chien”, “chat”, “autre”, et en la

12
 remplissant avec des NA (à l’aide de la fonction rep()), puis parcourez ce vecteur (avec la structure itérative
for) en affectant sa modalité à partir de ce qui est codé dans Favorite_species, en utilisant la strucure
itérative if. Pour gérer les NA dans Favorite_species, vous pouvez utilisez une structure conditionnelle avec
un if initial. Comme on aura mis des NA par défaut dans le nouveau facteur, pas besoin de réaffecter les
données manquantes.
3. Appliquez ensuite la fonction table() sur ce facteur pour voir les effectifs pour chaque modalité et vérifiez
que c’est cohérent avec votre première table faite sur Favorite_species.

Ecriture d’une fonction et application d’une fonction par groupe à l’aide de la fonction
tapply()
Afin de comprendre comment on écrit une fonction et comment on peut l’appliquer par groupe à l’aide de
tapply() testez le code suivant :

# Création d'une fonction

Q1 <- function(x){
quartile1 <- quantile(x, probs = 0.25, na.rm = TRUE)
return(quartile1)
}

# Création de la variable Genre (si non fait auparavant)

## création d'un vecteur de modalités dans l'ordre
## dans lesquelles elles ont été codées dans Gender
## en donnant le même nom aux deux dernières
Genres <- c("homme", "femme", "autre", "autre")
## Utilisation du code dans Gender comme index dans Genres
d$Genre <- as.factor(Genres[d$Gender])

# Application de cette fonction à l'âge de tous les répondants puis manuellement par genre
Q1(d$Age)
Q1(d$Age[d$Genre == "femme"])
Q1(d$Age[d$Genre == "homme"])

# Application automatique de la fonction par genre

tapply(d$Age, d$Genre, Q1)

1. A l’aide de la fonction tapply(), calculez la médiane des LAPS pour chaque modalité de la variable
Animal_favori que l’on vient de créer. Faites la même chose pour calculer les moyennes.
2. Faites une petite fonction qui affiche les quartiles, le min et le max, en utilisant les fonctions quantile(),
min() et max() et appliquez cette fonction pour calculer ces statistiques sur le LAPS par espèce (modalité
de Animal_favori) en utilisant la fonction tapply(). Pour gérer les données manquantes, utilisez les
arguments na.rm de ces fonctions.

Sauvegarde du jeu de données augmenté

A l’aide de la fonction write.table(), sauvegardez le jeu de données augmenté avec toutes les nouvelles variables
que vous avez créées, dans un fichier que l’on nommera Sandoe23augmente.txt et importez-le dans Excel pour
l’y retrouver.
Si vous souhaitez avoir la virgule comme séparateur de décimales (important ici uniquement pour la variable
AgeCR), il faut mettre l’argument dec = ",", mais dans ce cas il faudra bien penser à faire de même si vous
voulez importer à nouveau ce jeu de données dans R avec la fonction read.table().

13
Visualisation de données avec ggplot2
A partir du jeu de données recodé, faites des représentations graphiques intéressantes pour visualiser notamment
les variables LAPS de l’animal favori en fonction de l’âge, du genre et du revenu de son propriétaire, de son pays,
et de l’espèce, et de l’espèce de l’animal favori.

14