1 Qu’est-ce que R ?

  • R est un langage de programmation développé par Ross Ihaka et Robert Gentleman en 1993.
  • Utile pour manipuler, modéliser, “stocker, gérer” et analyser différents types d’informations.
  • Un outil très puissant pour les méthodes statistiques et graphiques.
  • Il comprend des bibliothèques pour l’économétrie (régression linéaire, séries temporelles, inférence statistique), les algorithmes de machine learning, le web scraping, les systèmes d’information géographique (SIG), entre autres.
  • Un outil performant pour communiquer votre travail : Markdown (présentations, PDF, HTML), Plotly (graphiques interactifs), création d’applications (Shiny), etc.

1.1 Un logiciel libre

  • Disponible en libre téléchargement sur le site officiel du CRAN = Comprehensive R Archive Network (c’est le site de référence pour R.)
  • Il contient non seulement les installeurs du logiciel mais également de nombreuses ressources : documentations, FAQ, tutoriels…
  • Installable sur la plupart des systèmes d’exploitation
  • Utilisé en recherche, en enseignement et en entreprise
  • Une communauté très active :
    • Forum des utilisateurs de R en français
    • Communauté française des utilisateurs de R (avec des packages spécifiques, qui permettent de gérer les changements de géographie communale par exemple) : Frrrenchies Slack de ces utilisateurs (pour les questions/réponses, actualités…)
    • Slack R-bloggers : https://www.r-bloggers.com/
    • Stackoverflow : https://stackoverflow.com/questions/tagged/r
    • C’est un logiciel libre : les utilisateurs ont la liberté d’exécuter, copier, distribuer, étudier, modifier et améliorer ce logiciel. R fait partie de la “galaxie” GNU (GNU’s Not Unix). R est donc libre, gratuit et multi-plateformes.

1.2 Interface RStudio

  • Environnement de développement conçu spécialement pour R
  • Interface utilisateur simple, conviviale, configurable et intégrant plusieurs outils

L’interface RStudio est composée de différents panneaux, dont l’arrangement peut être reconfiguré.

L’interface inclut une console, un navigateur de fichiers et graphiques et l’historique des commandes. L’espace de travail (Rscript) est disponible en cliquant sur File/New File/R Script.

2 Session et répertoire de travail

Un répertoire de travail R est un dossier à partir duquel le logiciel va chercher les fichiers de scripts, de données, graphiques, etc.

  • Une session de travail R commence à l’ouverture de RStudio et se termine en le quittant.
    • Tout ce qui a été fait au cours d’une session peut être enregistré dans le répertoire de travail

Quelques conseils pour bien organizer votre travail :

  • Créer un nouveau répertoire pour chaque projet.
  • Créer des sous-répertoires dans ce répertoire (Data, Figures, Output, etc.) pour bien sauvegarder les informations relatives à votre projet.

🧐 Exercice. Créer un répertoire de travail

  1. Créez un dossier nommé “DecouvrirR_exercice” sur votre poste de travail.

  1. De retour dans RStudio : Allez dans File / New Project / Existing Directory. Parcourez vos fichiers pour sélectionner le dossier que vous venez de créer.

  2. Sélectionnez Create Project.

  3. Le nom du projet doit apparaître dans la section supérieure droite de l’écran :

2.1 Interface utilisateur

L’interface de RStudio est simple : vous tapez une ligne de commande dans le panneau de la Console et vous appuyez sur Entrée pour l’exécuter. * Tout code saisi est appelé une commande (vous ordonnez à votre ordinateur de faire quelque chose).

Nous pouvons commander à R de fonctionner comme une calculatrice en tapant simplement 1 + 1 puis Entrée. Le résultat s’affiche immédiatement après la ligne de commande.

  • Tapez getwd() dans la console puis Entrée. Qu’est-ce que vous observez ?
    • Il est tous jour possible de definir autre répertoire de travail directement en utilisant setwd(’’).

R supporte évidemment des opérations beaucoup plus complexes. N’hésitez pas à explorer ses capacités.

2.2 Les Scripts dans RStudio

Exécuter du code depuis la console est efficace, mais présente des limites :

  • Pour réexécuter des commandes, il faut les ressaisir.
  • Les commandes complexes sont sujettes aux fautes de frappe.
  • Répéter des opérations nécessite de retaper tout le flux de code.

Les scripts R sont la solution : ce sont de simples fichiers texte contenant un ensemble de commandes. Vous pouvez les sauvegarder, les réexécuter, inclure des commentaires et les partager.

🧐 Exercice. Créer un script R

  1. Dans votre répertoire, créez un dossier nommé scripts.
  2. Dans Rstudio, cliquez sur File / New File / R Script. Alternatives : Utilisez l’icône “New File” ou le raccourci Ctrl+Shift+N.
  3. Sauvegardez votre script dans le répertoire scripts sous le nom 01_MyFirstScript.

🧐 Exercice. Prise en main du Script

💡 Astuce : les commentaires dans le script sont indiqués par le symbole dièse #.

  1. Écrivez votre nom, la date et les instructions de la tâche au début du script en utilisant des commentaires.

  1. Écrivez le code dir( ). Pour exécuter une ligne des commands dans un script, placez le curseur sur la ligne et appuyez sur Ctrl+Enter. Qu’est-ce que vous observez ?

  2. Exécuter le code getwb( ). Qu’est-ce que vous observez ?

  3. Calculer le resultat de cette opperation : 11 divisé par 7. Vérifiez le résultat dans la console.

3 Terminologie de base et syntaxe

  • Une valeur constitue l’unité de base des données pour R. Comme pour la plupart des logiciels, elles peuvent être de trois types :
    • Numérique : entier, double
    • Caractère : texte ou code
    • Logique : booléens

En programmation ou en analyse de données, il est crucial de distinguer les types de données car les fonctions applicables varient. Par exemple, on peut additionner deux nombres, mais on “concatène” deux chaînes de caractères (du texte).

  • En langage R, une variable est un conteneur qui sert à stocker une information (une valeur, un vecteur, un matrix, une base de données, etc.) afin de pouvoir la réutiliser plus tard dans votre code. Considérez une variable comme une boîte étiquetée : l’étiquette est le nom de la variable, et le contenu de la boîte est la donnée.

  • Pour créer une variable, on utilise généralement l’opérateur d’assignation <-. Bien que le signe = fonctionne aussi, <- est la norme privilégiée par la communauté. Voici quelques exemples :

# Syntaxe : nom_variable <- valeur
age <- 25
prenom <- "Marc"
est_etudiant <- TRUE

Caractéristiques importantes :

  • Sensibilité à la casse : R fait la différence entre les majuscules et les minuscules. Ma_Variable et ma_variable sont deux objets totalement différents.

  • Typage dynamique : Vous n’avez pas besoin de préciser si la variable est un nombre ou du texte ; R le comprend automatiquement lors de l’assignation.

  • Réécriture : Si vous assignez une nouvelle valeur à une variable existante, l’ancienne est effacée.

x <- 10
x <- 20  # Maintenant, x vaut 20

Les règles de nommage

Pour que R accepte le nom de votre variable, vous devez respecter quelques règles :

  • Commencer par une lettre.
  • Pas d’espaces : Utilisez des underscores (_) ou des points (.) à la place (ex: ma_variable ou ma.variable).
  • Pas de caractères spéciaux : Évitez les accents, les signes $, %, #, etc.
  • Chiffres : Les chiffres sont autorisés, mais jamais au début du nom (ex: v2 est correct, 2v provoquera une erreur).

🧐 Exercice. Déclarer une variable numérique, une entière, une logique et une chaîne de caractères

  1. Notez cette exercice dans votre script.
  2. Déclarer une variable x de type numérique avec une valeur égale à 10.
  3. Utilisez la commande class() pour vérifier le type de valeur. Que remarquez-vous dans le panneau de l’historique ?
x <- 10
class(x)
## [1] "numeric"
  1. Déclarer une variable y de type texte avec une valeur égale à Hello World
y <- "Hello world"
class(y)
## [1] "character"
  1. Déclarer une variable z de type logique avec une valeur égale à TRUE
z <- TRUE
class(z)
## [1] "logical"

3.1 Opérations de base

Variables du type numérique

Une fois vos données stockées dans des variables numériques, vous pouvez les manipuler pour effectuer des calculs. Le langage R utilise des symboles intuitifs, appelés opérateurs arithmétiques, qui fonctionnent de la même manière qu’une calculatrice standard. Ces opérations permettent de transformer vos données brutes en informations utiles, qu’il s’agisse de simples totaux ou de calculs mathématiques plus complexes comme les puissances ou les racines carrées.

Tableau des Opérateurs Arithmétiques
Opérateur Description Exemple Résultat
+ Addition 5 + 2 7
- Soustraction 5 - 2 3
* Multiplication 5 * 2 10
/ Division 10 / 2 5
^ ou ** Exposant (Puissance) 10 ^ 2 100
sqrt(x) Racine carrée sqrt(25) 5

💡 Astuce : Le résultat des opérations peut aussi être stocké dans une variable. Par exemple :

x  <- 10
xx <- 20
resultat <- x + xx

# Cette ligne permet d'afficher l'information stockée dans z dans la console :
resultat
## [1] 30

3.2 📒 C’est à vous

🧐 Exercice. Calculer l’hypoténuse (c) d’un triangle rectangle de côtés a = 5 et b = 7.

Le théorème de Pythagore stipule que : \(c = \sqrt{a^2 + b^2}\).

## [1] "Le résultat est 8.60232526704263"

3.3 Manipulation des chaînes de caractères (Strings)

En analyse de données, vous travaillerez souvent avec du texte (noms, catégories, adresses). R traite ces données comme des chaînes de caractères (strings). Pour les manipuler efficacement, R propose des outils natifs permettant de découper, d’extraire ou d’assembler du texte selon vos besoins. Fonctions pour les variables textuelles :

  • Extraire ou remplacer des sous-chaînes. La fonction substr() permet de récupérer une partie précise d’un texte en indiquant le point de départ et le point d’arrivée.
# Syntaxe : substr(x, start=n1, stop=n2)
x <- "abcdef"
substr(x, 2, 4) # Extrait du 2ème au 4ème caractère
## [1] "bcd"
  • Diviser une chaîne de caractères. La fonction strsplit()découpe un texte à chaque fois qu’elle rencontre un motif spécifique (un espace, une virgule, etc.).
# Diviser les éléments au niveau d'un motif (split)
# strsplit(x, split)
strsplit(x, "") # Divise chaque caractère (motif vide)
## [[1]]
## [1] "a" "b" "c" "d" "e" "f"
y <- "Hello world"
strsplit(y, " ") # Divise au niveau de l'espace
## [[1]]
## [1] "Hello" "world"
  • Concaténer (coller) des chaînes avec un séparateur. La fonction paste() assemble plusieurs morceaux de texte en insérant un séparateur entre eux.
# Concaténer des chaînes avec un séparateur (sep)
# paste(x, y, sep)
paste(y, x, sep = " + ")
## [1] "Hello world + abcdef"
  • Concaténer sans séparateur. La fonction paste0() est une version simplifiée qui colle les textes directement les uns aux autres.
# Concaténer des chaînes sans aucun espace ni séparateur
paste0(y, x)
## [1] "Hello worldabcdef"
# On peut obtenir le même résultat avec les deux fonctions :
# paste0 est juste plus rapide si vous n'avez pas besoin de séparateur.
paste0(y, " + ", x)
## [1] "Hello world + abcdef"
Manipulation des chaînes de caractères
Fonction Description Exemple Résultat
substr(x, start, stop) Extrait une partie du texte substr(‘R-Studio’, 1, 1) ‘R’
strsplit(x, split) Divise le texte selon un motif strsplit(‘A-B’, ‘-’) list(‘A’, ‘B’)
paste(x, y, sep) Colle des textes avec un séparateur paste(‘R’, ‘Ready’, sep=’ is ’) ‘R is Ready’
paste0(x, y) Colle des textes sans espace paste0(‘Data’, ‘Science’) ‘DataScience’

3.4 Les fonctions et les valeurs particulières

  • NA : valeur manquante (Not Available) dans une dataset ou en résultat d’une fonction
  • NaN : pas un nombre (Not a Number) lorsqu’une fonction tente de diviser par 0
  • -Inf, Inf : infini positif ou négatif lorsque une fonction diverge

Une valeur manquante peut perturber l’exécution d’une fonction :

⚠️ Les noms de ces valeurs particulières sont “réservés” par R, ils ne peuvent pas être utilisés comme nom de variable. C’est également le cas des booléens (TRUE, FALSE, T et F)

# Valeur manquante
x <- NA
y <- 2
z <- 3

(x + y + z) /3
## [1] NA
# Infini
mean(-1/0)
## [1] -Inf

3.5 Fonctions intégrées

R propose de nombreuses fonctions intégrées prêtes à l’emploi qui permettent d’effectuer des calculs complexes sans effort supplémentaire. Ce tableau récapitule les commandes essentielles pour explorer et résumer statistiquement vos séries de données en un clin d’œil.

Fonctions de transformation
Fonction Description Exemple Résultat
abs(x) Valeur absolue abs(-5) 5
sqrt(x) Racine carrée sqrt(16) 4
round(x, digits=n) Arrondi (ex: n décimales) round(1.325, 2) 1.33
log(x) Logarithme népérien log(1) 0
exp(x) Exponentielle (\(e^x\)) exp(0) 1

Voici quelques functions statistiques

Fonctions statistiques de base
Fonction Description Exemple Résultat
mean(x) Moyenne arithmétique mean(c(1, 5)) 3
sd(x) Écart-type sd(c(1, 5)) 2.82
var(x) Variance var(c(1, 5)) 8
median(x) Médiane median(c(1, 3, 5)) 3
sum(x) Somme sum(c(1, 2)) 3
min(x) Minimum min(c(1, 5)) 1
max(x) Maximum max(c(1, 5)) 5

3.6 Operations logiques

Les opérations logiques sont indispensables pour filtrer vos données ou tester des conditions spécifiques au sein de vos scripts. Elles renvoient systématiquement des valeurs TRUE (vrai) ou FALSE (faux), permettant ainsi à R de prendre des décisions basées sur vos critères.

Opérateurs de comparaison et logique
Opérateur Description Exemple Résultat
> ou < Supérieur ou inférieur 5 > 2 TRUE
>= ou <= Supérieur/Inférieur ou égal 5 >= 5 TRUE
== Strictement égal 5 == 2 FALSE
!= Différent de 5 != 2 TRUE
!x Non x (Inverse) !TRUE FALSE
x & y x ET y TRUE & FALSE FALSE
isTRUE(x) Teste si x est VRAI isTRUE(1 < 2) TRUE

⚠️ Attention: Les symboles = et == n’ont PAS la même fonction en R. Le symbole = est utilisé pour l’assignation (comme <-), tandis que == est utilisé exclusivement pour tester une égalité.

# Utilisation d'une opération logique
mon_score <- 15.75
score_arrondi <- round(mon_score,0)

# Est-ce que mon score est suffisant pour gagner (>= 10) ?
a_gagne <- score_arrondi >= 10

# Comparaison entre deux variables
score_adversaire <- 16
est_meilleur <- score_arrondi > score_adversaire

# --- Affichage des résultats ---
print(score_arrondi)  
## [1] 16
print(a_gagne)         
## [1] TRUE
print(est_meilleur)
## [1] FALSE

3.7 Les Facteurs (Factors)

Les facteurs sont la méthode utilisée par R pour stocker des données catégorielles, comme l’ethnicité ou la couleur des yeux. Considérez un facteur comme une variable de genre : il ne peut prendre que certaines valeurs spécifiques (comme “masculin” ou “féminin”), et ces valeurs peuvent avoir leur propre ordre logique (par exemple, pour classer des niveaux de satisfaction). Cette structure rend les facteurs extrêmement utiles pour enregistrer les niveaux de traitement d’une étude ou toute autre variable qualitative.

Pour créer un facteur, il suffit de passer un vecteur atomique à la fonction factor(). En arrière-plan, R effectue alors deux opérations :

  1. Il recode les données du vecteur sous forme d’entiers et les stocke dans un vecteur de type integer.

  2. Il ajoute un attribut levels (niveaux), qui contient les étiquettes utilisées pour l’affichage, et un attribut class qui définit l’objet comme étant un factor.

# 1. Création d'un vecteur de texte (caractères)
couleurs_yeux_brutes <- c("bleu", "marron", "vert", "marron", "bleu")

# 2. Transformation en facteur
yeux_factor <- factor(couleurs_yeux_brutes)

# 3. Visualisation
yeux_factor
## [1] bleu   marron vert   marron bleu  
## Levels: bleu marron vert
# Remarquez que R affiche les niveaux (levels) en bas du résultat.

# 4. Vérification de la structure interne
attributes(yeux_factor)
## $levels
## [1] "bleu"   "marron" "vert"  
## 
## $class
## [1] "factor"
unclass(yeux_factor)
## [1] 1 2 3 2 1
## attr(,"levels")
## [1] "bleu"   "marron" "vert"

4 Les objets dans R

  • R est un langage de programmation par objet (object-oriented programming language). Ça signifie qu’on peut allouer un nom à des valeurs qu’on a créées afin de les enregistrer dans un espace de travail.

  • Un objet est composé de trois parties :

    1. Valeur. Numérique, logique, caractère, valeur manquante, le résultat d’un opération…
    2. L’identifiant. Nom qui est assigné à la valeur d’intérêt.
    3. L’assignation. L’opérateur d’assignation ressemble à une flèche (<-)

R classifie les données selon la nature des valeurs contenues dans un objet. La figure suivante illustre les types de données couramment rencontrés dans R.

4.1 Vectors

Un vecteur est un tableau à une seule dimension. On peut créer un vecteur à partir de tous les types de données que nous venons de définir (numérique, texte ou logique). La manière la plus simple de construire ces structures de données en R est d’utiliser la commande c().

🧐 Le c signifie combine (combiner). Il sert à regrouper des valeurs individuelles pour former un seul bloc de données. C’est une fonction facile et très utile, alors rappelez-vous en !

🧐 Astuce : Le symbol : peut etre tuliser pour creer une sequence numerique des interger:

# Combiner trois chiffres dans un seul vecteur
mes_notes <- c(12, 15, 18)
mes_notes
## [1] 12 15 18
# Combiner des noms (chaînes de caractères)
etudiants <- c("Alice", "Bob", "Charlie")
etudiants
## [1] "Alice"   "Bob"     "Charlie"

🧐 Astuce : Le symbole : peut être utilisé pour créer une séquence numérique continue d’entiers :

# Combiner trois chiffres dans un seul vecteur
mon_seq <- c(12:20)
mon_seq
## [1] 12 13 14 15 16 17 18 19 20

4.1.1 Indexer un vecteur

R nous permet d’extraire certaines parties d’un objet en indexant ce dernier. Il suffit de spécifier la position des valeurs à l’intérieur d’un objet qu’on souhaite extraire à l’aide des crochets [ ].

# Extrayons le deuxième élément du vecteur numérique.
mon_seq[2]
## [1] 13
# Extrayons les 2ème et 4ème éléments du vecteur numérique.
mon_seq[c(2, 4)]
## [1] 13 15
# Extrayons tous les éléments du vecteur numérique sauf les deux premières.
mon_seq[c(-1, -2)]
## [1] 14 15 16 17 18 19 20
# Si nous sélectionnons une position qui n'existe pas dans le résultat est une valeur manquante
mon_seq[c(8, 10)]
## [1] 19 NA
# Nous pouvons également utiliser des opérateurs logiques pour sélectionner des valeurs.
mon_seq[mon_seq > 15]
## [1] 16 17 18 19 20

4.1.2 Opérations sur les vecteurs

Il est possible de manipuler les vecteurs de différentes manières :

  • Additionner deux vecteurs
vec_num1 <- c(2,3,5)
vec_num2 <- c(10:12)

vec_num1 + vec_num2
## [1] 12 14 17
  • Multiplier un vecteur par un scalaire (mise à l’échelle)
vec_num3 <- vec_num2 * 3
vec_num3
## [1] 30 33 36

⚠️ Attention: Soyez prudent lors des opérations entre vecteurs. Si les vecteurs n’ont pas la même taille, R utilise une règle de recyclage qui peut donner des résultats inattendus par rapport à l’algèbre classique. Au lieu de s’arrêter et d’afficher une erreur, R va répéter (recycler) les éléments du vecteur le plus court jusqu’à ce qu’il atteigne la taille du plus long.

# Exemple
v_court <- c(1, 2)
v_long  <- c(10, 20, 30, 40)

# R transforme mentalement v_court en c(1, 2, 1, 2)
v_long + v_court
## [1] 11 22 31 42

4.2 📒 C’est à vous

  1. Dans cet exercice, nous allons manipuler un vecteur de texte représentant des articles à acheter. Copiez le code suivant dans votre script R et essayez de résoudre les défis proposés. Commencez par créer ce vecteur de 5 fruits et, à l’aide des crochets [ ], écrivez le code pour répondre aux consignes suivantes :
panier <- c("pomme", "banane", "fraise", "kiwi", "orange")
Tableau des exercices d’indexation
Défi Objectif Résultat.attendu
Défi A Extraire le 3ème élément (la fraise). 'fraise'
Défi B Extraire le premier et le dernier fruit. 'pomme' 'orange'
Défi C Afficher tout le panier sauf la banane. Tous sauf banane
Défi D Chercher le 10ème élément (qui n’existe pas). NA
Défi E (Avancé) Extraire uniquement l’élément ‘kiwi’ via un test logique. 'kiwi'
  1. Nous allons analyser les revenus d’un magasin. Cet exercice vous fera passer de la donnée brute à une conclusion statistique. Copiez ce vecteur qui représente les ventes quotidiennes (en euros) du lundi au dimanche et utiliser des fonctions statistiques pour répondre aux questions suivantes :
Guide de résolution de l’exercice
Étape Objectif Fonction…Opérateur
A Calculer le revenu total de la semaine. sum()
B Trouver la vente la plus élevée. max()
C Calculer la moyenne des ventes. mean()
D Arrondir cette moyenne à 1 décimale. round()
E Identifier les jours avec des ventes > 200€. &gt;

4.3 Les Matrices

Une fonction matrix en R est un tableau à deux dimensions qui possède un nombre m de lignes et un nombre n de colonnes. En d’autres termes, une matrice, dans la programmation R, est une combinaison de deux ou plusieurs vecteurs contenant le même type de données.

On peut créer une matrice avec la fonction matrix(data, nrow, ncol, byrow = FALSE)

Où : * nrow : Le nombre de lignes. * ncol : Le nombre de colonnes. * byrow : Si TRUE, les lignes sont remplies de gauche à droite. Par défaut (byrow = FALSE), la matrice est remplie par colonnes (du haut vers le bas).

# Créer une matrice de $5 \times 3$ contenant les nombres de 1 à 15
A <- matrix(1:15, nrow = 5, ncol = 3, byrow = TRUE)
A
##      [,1] [,2] [,3]
## [1,]    1    2    3
## [2,]    4    5    6
## [3,]    7    8    9
## [4,]   10   11   12
## [5,]   13   14   15

4.3.1 Opérations avec une matrice

Il est possible de manipuler les matrices de différentes manières :

Additionner deux matrices

A <- matrix(1:15, nrow = 5, ncol = 3, byrow = TRUE)
B <- matrix(16:30, nrow = 5, ncol = 3, byrow = TRUE)

A + B
##      [,1] [,2] [,3]
## [1,]   17   19   21
## [2,]   23   25   27
## [3,]   29   31   33
## [4,]   35   37   39
## [5,]   41   43   45

Multiplier une matrice par un scalaire (mise à l’échelle)

C <- A * 2
C
##      [,1] [,2] [,3]
## [1,]    2    4    6
## [2,]    8   10   12
## [3,]   14   16   18
## [4,]   20   22   24
## [5,]   26   28   30

⚠️ Attention: Encore une fois, soyez prudent lors des opérations sur les matrices. Les résultats peuvent ne pas suivre les propriétés algébriques classiques (comme la multiplication matricielle réelle qui nécessite l’opérateur %*%).

4.3.2 Manipuler la structure : cbind() et rbind()

Vous pouvez ajouter des colonnes ou des lignes à une matrice existante avec les fonctions cbind() (column-bind) et rbind() (row-bind).

# Ajouter une colonne (de 1 à 5) à la matrice C
vc <- c(1:5)
cbind(C,vc)
##               vc
## [1,]  2  4  6  1
## [2,]  8 10 12  2
## [3,] 14 16 18  3
## [4,] 20 22 24  4
## [5,] 26 28 30  5
# Ajouter une ligne (de 1 à 3) à la matrice C
rbind(C, 1:3)
##      [,1] [,2] [,3]
## [1,]    2    4    6
## [2,]    8   10   12
## [3,]   14   16   18
## [4,]   20   22   24
## [5,]   26   28   30
## [6,]    1    2    3

4.3.3 Indexation d’une matrice (Slicing)

On peut sélectionner un ou plusieurs éléments d’une matrice en utilisant les crochets [ ]. La syntaxe est la suivante : [lignes, colonnes]

Par exemple :

  • C[1, 2] : sélectionne l’élément à la première ligne et deuxième colonne de la matrice C.
  • C[1:3, 2:3] : extrait une sous-matrice contenant les lignes 1, 2, 3 et les colonnes 2, 3.
  • C[, 1] : sélectionne tous les éléments de la première colonne.
  • C[1, ] : sélectionne tous les éléments de la première ligne.
# Visualisons C
C
##      [,1] [,2] [,3]
## [1,]    2    4    6
## [2,]    8   10   12
## [3,]   14   16   18
## [4,]   20   22   24
## [5,]   26   28   30
# Exemples d'extraction
C[1, 2]
## [1] 4
C[1:3, 2:3]
##      [,1] [,2]
## [1,]    4    6
## [2,]   10   12
## [3,]   16   18
C[, 1]
## [1]  2  8 14 20 26
C[1, ]
## [1] 2 4 6

4.4 📒 C’est à vous

Imaginons que nous suivons les notes de 3 étudiants dans 3 matières différentes. Chaque ligne représente un étudiant et chaque colonne une matière.

Résumé des étapes du défi
Étape Action.à.réaliser Outil.à.utiliser
1 Créer une matrice notes de 3x3 avec les valeurs de 10 à 18, remplie par ligne. matrix()
2 Ajouter un 4ème étudiant (une ligne) avec les notes : 20, 20, 20. rbind()
3 Extraire la note du 2ème étudiant pour la 3ème matière. [row, col]
4 Calculer la somme de la première colonne (Matière 1). sum() et [ , col]

4.5 Les Tableaux (Arrays)

La fonction array() permet de créer un tableau n-dimensionnel. Par exemple, vous pouvez utiliser array() pour organiser des valeurs dans un cube à trois dimensions ou même un hypercube à 4, 5 ou \(n\) dimensions.

La fonction array() est moins personnalisable que matrix() ; elle revient essentiellement à définir l’attribut de dimension (dim()) d’un vecteur. Pour utiliser array(), vous devez fournir un vecteur atomique comme premier argument, et un vecteur de dimensions (appelé dim()) comme second argument :

ar <- array(c(11:14, 21:24, 31:34), dim = c(2, 2, 3))
ar
## , , 1
## 
##      [,1] [,2]
## [1,]   11   13
## [2,]   12   14
## 
## , , 2
## 
##      [,1] [,2]
## [1,]   21   23
## [2,]   22   24
## 
## , , 3
## 
##      [,1] [,2]
## [1,]   31   33
## [2,]   32   34

4.6 Les Listes (Lists)

Les listes ressemblent aux vecteurs atomiques car elles regroupent des données dans un ensemble unidimensionnel. Cependant, il y a une différence majeure : les listes ne regroupent pas seulement des valeurs individuelles, elles regroupent des objets R entiers.

Une liste peut donc contenir des objets de types différents : un vecteur numérique, un vecteur de caractères, et même une autre liste ! Caractéristiques principales : * Hétérogénéité : Contrairement aux vecteurs, une liste peut mélanger des chiffres, du texte et des matrices. * Flexibilité : Vous pouvez créer une liste contenant un vecteur numérique de taille 31 en premier élément, un mot simple en deuxième, et une autre liste en troisième.

💡 Si un vecteur est comme une boîte de crayons de la même couleur, une liste est comme un sac à dos : vous pouvez y mettre un livre, une pomme et une trousse (qui contient elle-même d’autres objets).

list1 <- list(100:130, "R", list(TRUE, FALSE))
list1
## [[1]]
##  [1] 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118
## [20] 119 120 121 122 123 124 125 126 127 128 129 130
## 
## [[2]]
## [1] "R"
## 
## [[3]]
## [[3]][[1]]
## [1] TRUE
## 
## [[3]][[2]]
## [1] FALSE

Les indices entre doubles crochets [[ ]] vous indiquent quel élément de la liste est affiché. Les indices entre crochets simples [ ] vous indiquent quel sous-élément au sein d’un élément est affiché.

Par exemple, 100 est le premier sous-élément du premier élément de la liste. “R” est le premier sous-élément du deuxième élément. Ce système de double notation existe parce que chaque élément d’une liste peut être n’importe quel objet R, y compris un nouveau vecteur (ou une autre liste) possédant ses propres indices.

ma_liste <- list(c(100, 200), "R")

# Affichage de l'élément global (le compartiment)
ma_liste[[1]] 
## [1] 100 200
# Affichage du sous-élément (le contenu du compartiment)
ma_liste[[1]][1]
## [1] 100

4.7 Les Data Frames

Les Data Frames sont la version bidimensionnelle d’une liste. C’est, de loin, la structure de stockage la plus utile pour l’analyse de données. Vous pouvez considérer un data frame comme l’équivalent R d’une feuille de calcul Excel, car il stocke les données dans un format similaire.

Structure et caractéristiques Les data frames regroupent des vecteurs au sein d’un tableau à deux dimensions. Chaque vecteur devient une colonne du tableau. Par conséquent : * Chaque colonne peut contenir un type de données différent (numérique, texte, logique, etc.). * À l’intérieur d’une même colonne, chaque cellule doit impérativement être du même type. * Toutes les colonnes d’un data frame doivent avoir exactement la même longueur.

Création manuelle d’un Data Frame Créer un data frame à la main demande un peu de saisie, mais vous pouvez le faire très simplement avec la fonction data.frame().

Il suffit de fournir à la fonction plusieurs vecteurs séparés par des virgules. Chaque vecteur doit être associé à un nom qui décrit son contenu. La fonction transformera alors chaque vecteur en une colonne de votre nouveau tableau :

# Exemple de création manuelle
mon_df <- data.frame(
  id = 1:3,
  nom = c("Alice", "Bob", "Charlie"),
  admis = c(TRUE, TRUE, FALSE)
)

# Affichage du data frame
mon_df
##   id     nom admis
## 1  1   Alice  TRUE
## 2  2     Bob  TRUE
## 3  3 Charlie FALSE

💡 Dans la plupart des cas réels, vous ne créerez pas vos data frames à la main. Vous les importerez directement depuis des fichiers .csv ou .xlsx en utilisant des fonctions comme read.csv().

4.7.1 Indexation d’une Data Frame

Le symbole $ est le raccourci le plus utilisé en R pour extraire une colonne spécifique d’un Data Frame. C’est comme si vous disiez à R : Dans ce tableau, va chercher cette colonne précise.

Lorsque vous utilisez le symbole $, R vous suggère automatiquement les noms des colonnes disponibles. Le résultat de cette opération est un vecteur.

# Reprenons notre data frame 'mon_df'
# Extraire uniquement la colonne des noms
noms_etudiants <- mon_df$nom

# Afficher le résultat
noms_etudiants
## [1] "Alice"   "Bob"     "Charlie"

Une fois que vous avez extrait une colonne avec $, vous pouvez l’utiliser comme n’importe quel vecteur avec les fonctions que nous avons vues précédemment :

# Calculer la moyenne directement sur une colonne
moyenne_id <- mean(mon_df$id)

# Faire un test logique sur une colonne
qui_est_admis <- mon_df$admis == TRUE

Comme les Data Frames possèdent deux dimensions (des lignes et des colonnes), R nous offre la flexibilité d’utiliser la notation matricielle. Cette méthode est souvent plus puissante que le simple symbole $ car elle permet de sélectionner plusieurs lignes et colonnes en même temps.

Puisqu’un Data Frame est un tableau, la règle d’or apprise avec les matrices s’applique toujours : df[indice_ligne, indice_colonne]. * Extraire une cellule précise : df[1, 2] vous donne la valeur située à la 1ère ligne et 2ème colonne. * Extraire une ligne entière : df[3, ] (on laisse vide après la virgule pour dire “toutes les colonnes”). * Extraire une colonne entière : df[, 1] (on laisse vide avant la virgule pour dire “toutes les lignes”).

4.8 📒 C’est à vous

Votre mission est de créer un tableau de suivi, d’ajuster les notes et d’identifier les étudiants qui recevront une mention.

  1. Créer un Data Frame nommé promo avec 3 colonnes et 5 observations : nom, note et presence.
  2. Extraire la colonne note pour calculer la moyenne de la classe.
  3. Ajouter une nouvelle colonne note_finale qui ajoute +1 point de bonus à tout le monde.
  4. Créer un vecteur logique mention pour savoir qui a une note_finale \(\ge 15\).