Introduction à R
Last updated on 2026-11-07 | Edit this page
Estimated time: 120 minutes
Overview
Questions
- Premières commandes en R
Objectives
- Définissez les termes suivants en lien avec R : objet, affecter, appeler, fonction, arguments, options.
- Attribuer des valeurs à des objets dans R.
- Apprendre à nommer des objets
- Utiliser des commentaires pour éclairer le script.
- Résoudre des opérations arithmétiques simples dans R.
- Appeler des fonctions et utiliser des arguments pour modifier leurs options par défaut.
- Examiner le contenu des vecteurs et en manipuler le contenu.
- Sélectionner des sous-ensembles de vecteurs et en extraire des valeurs.
- Analyser des vecteurs contenant des données manquantes.
Cet épisode est basé sur la leçon Data Analysis and Visualisation in R for Ecologists de Data Carpentries.
Création d’objets dans R
Vous pouvez obtenir des résultats depuis R en saisissant simplement des expressions mathématiques dans la console :
R
3 + 5
OUTPUT
[1] 8R
12 / 7
OUTPUT
[1] 1.714286Cependant, pour faire des choses utiles et intéressantes, nous devons
affecter des valeurs à des objets. Pour créer un
objet, nous devons lui donner un nom suivi de l’opérateur d’affectation
<-, puis de la valeur que nous souhaitons lui affecter
:
R
weight_kg <- 55
<- est l’opérateur d’affectation. Il attribue des
valeurs à droite à des objets à gauche. Ainsi, après avoir exécuté
x <- 3, la valeur de x est 3.
La flèche peut être lue comme 3 va dans x.
Pour des raisons historiques, vous pouvez également utiliser
= pour les affectations, mais pas dans tous les contextes.
En raison des légères
différences de syntaxe, il est recommandé d’utiliser toujours
<- pour les affectations.
Dans RStudio, saisir Alt + - (appuyer sur
Alt en même temps que la touche -) permet d’écrire
<- en un seul coup de touche sur un PC, tandis que
saisir Option + - (appuyer sur Option
en même temps que la touche -) fait de même sur un Mac.
Nommer les variables
Les objets peuvent porter n’importe quel nom, tel que x,
current_temperature ou subject_id. Il convient
que les noms de vos objets soient explicites et pas trop longs. Ils ne
peuvent pas commencer par un chiffre (2x n’est pas valide,
mais x2 l’est). R est sensible à la casse (par exemple,
weight_kg est différent de Weight_kg).
Certains noms ne peuvent pas être utilisés car ils correspondent aux
noms de fonctions fondamentales de R (par exemple, if,
else, for ; voir la page du manuel Reserved
Words in R pour une liste complète). En général, même si c’est
autorisé, il est préférable de ne pas utiliser les noms d’autres
fonctions (par exemple, c, T,
mean, data, df,
weights). En cas de doute, consultez l’aide pour voir si le
nom est déjà utilisé. Il est également préférable d’éviter les points
(.) au sein du nom d’un objet, comme dans
my.dataset. De nombreuses fonctions en R contiennent des
points dans leur nom pour des raisons historiques, mais comme les points
ont une signification spéciale en R (pour les méthodes) et dans d’autres
langages de programmation, il est préférable de les éviter. Il est
également recommandé d’utiliser des noms communs pour les objets et des
verbes pour les fonctions. Il est important d’être cohérent dans la mise
en forme de votre code (l’endroit où vous placez les espaces, la manière
dont vous nommez les objets, etc.). L’utilisation d’un style de codage
cohérent rend votre code plus lisible pour vous-même à l’avenir et pour
vos collaborateurs. En R, certains guides de style populaires sont celui
de Google,
le style de tidyverse et le
guide
de style de Bioconductor. Celui de tidyverse est très complet et
peut sembler accablant au début. Vous pouvez installer le package lintr
pour vérifier automatiquement les problèmes de mise en forme de votre
code.
Objets vs. variables : Ce que l’on appelle
objectsdansRest appelévariablesdans de nombreux autres langages de programmation. Selon le contexte,objectetvariablepeuvent avoir des significations radicalement différentes. Cependant, dans cette leçon, les deux termes sont utilisés comme des synonymes. Pour plus d’informations, voir ici.
Lorsqu’on attribue une valeur à un objet, R n’affiche rien. Vous pouvez forcer R à afficher la valeur en utilisant des parenthèses ou en saisissant le nom de l’objet :
R
weight_kg <- 55 # doesn't print anything
(weight_kg <- 55) # but putting parenthesis around the call prints the value of `weight_kg`
OUTPUT
[1] 55R
weight_kg # and so does typing the name of the object
OUTPUT
[1] 55Maintenant que R a weight_kg en mémoire, nous pouvons
effectuer des opérations arithmétiques avec celui-ci. Par exemple, nous
souhaiterions peut-être convertir ce poids en livres (le poids en livres
est 2,2 fois le poids en kg) :
R
2.2 * weight_kg
OUTPUT
[1] 121Nous pouvons également modifier la valeur d’un objet en lui attribuant une nouvelle valeur :
R
weight_kg <- 57.5
2.2 * weight_kg
OUTPUT
[1] 126.5Cela signifie que l’attribution d’une valeur à un objet ne modifie
pas les valeurs des autres objets. Par exemple, stockons le poids de
l’animal en livres dans un nouvel objet, weight_lb :
R
weight_lb <- 2.2 * weight_kg
puis modifier weight_kg en 100.
R
weight_kg <- 100
Défi :
Selon vous, quel est le contenu actuel de l’objet
weight_lb ? 126.5 ou 220 ?
Commentaires
Le caractère de commentaire dans R est # ; tout ce qui
se trouve à droite d’un # dans un script sera ignoré par R.
Il est utile de laisser des notes et des explications dans vos
scripts.
RStudio permet de commenter ou de décommenter facilement un paragraphe : après avoir sélectionné les lignes que vous souhaitez commenter, appuyez simultanément sur Ctrl + Shift + C sur votre clavier. Si vous ne souhaitez commenter qu’une seule ligne, vous pouvez placer le curseur n’importe où sur cette ligne (c’est-à-dire qu’il n’est pas nécessaire de sélectionner l’intégralité de la ligne), puis appuyer sur Ctrl + Shift + C.
Défi
Quelles sont les valeurs après chaque instruction dans ce qui suit ?
R
mass <- 47.5 # mass?
age <- 122 # age?
mass <- mass * 2.0 # mass?
age <- age - 20 # age?
mass_index <- mass/age # mass_index?
Fonctions et leurs arguments
Les fonctions sont des « scripts préparés » qui automatisent des
ensembles de commandes plus complexes, notamment des opérations
d’affectation, etc. De nombreuses fonctions sont prédéfinies, ou peuvent
être rendues disponibles en important des packages R (on en
reparlera plus tard). Une fonction reçoit généralement un ou plusieurs
paramètres appelés arguments. Les fonctions renvoient souvent
(mais pas toujours) une valeur. Un exemple type serait la
fonction sqrt(). L’entrée (l’argument) doit être un nombre,
et la valeur de retour (en fait, la sortie) est la racine carrée de ce
nombre. L’exécution d’une fonction (« son lancement ») est appelée
appel de la fonction. Un exemple d’appel de fonction est :
R
b <- sqrt(a)
Ici, la valeur de a est transmise à la fonction
sqrt(), la fonction sqrt() calcule la racine
carrée et renvoie la valeur qui est ensuite affectée à l’objet
b. Cette fonction est très simple, car elle ne prend qu’un
seul argument.
La « valeur » de retour d’une fonction n’a pas nécessairement besoin
d’être numérique (comme celle de sqrt()), et elle n’a pas
non plus besoin d’être un seul élément : elle peut être un ensemble
d’éléments, voire un jeu de données. Nous verrons cela lorsque nous
lirons des fichiers de données dans R.
Les arguments peuvent être n’importe quoi, et non seulement des nombres ou des noms de fichiers, mais aussi d’autres objets. La signification exacte de chaque argument varie selon la fonction et doit être consultée dans la documentation (voir ci-dessous). Certaines fonctions acceptent des arguments qui peuvent être spécifiés par l’utilisateur ou, s’ils sont omis, prendre une valeur par défaut : ceux-ci sont appelés options. Les options sont généralement utilisées pour modifier le mode de fonctionnement de la fonction, par exemple pour déterminer si elle ignore les « valeurs erronées » ou quel symbole utiliser dans un graphique. Cependant, si vous souhaitez quelque chose de spécifique, vous pouvez spécifier une valeur de votre choix qui sera utilisée à la place de la valeur par défaut.
Essayons une fonction capable de prendre plusieurs arguments :
round().
R
round(3.14159)
OUTPUT
[1] 3Ici, nous avons appelé round() avec un seul argument,
3.14159, et celui-ci a renvoyé la valeur 3.
C’est parce que la valeur par défaut consiste à arrondir au nombre
entier le plus proche. Si nous souhaitons obtenir plus de chiffres, nous
pouvons voir comment faire en obtenant des informations sur la fonction
round. Nous pouvons utiliser args(round) ou
consulter l’aide de cette fonction via ?round.
R
args(round)
OUTPUT
function (x, digits = 0, ...)
NULLR
?round
On voit que si l’on souhaite un nombre de chiffres différent, on peut
saisir digits=2 ou le nombre souhaité.
R
round(3.14159, digits = 2)
OUTPUT
[1] 3.14Si vous fournissez les arguments exactement dans le même ordre que celui utilisé pour leur définition, vous n’avez pas besoin de les nommer :
R
round(3.14159, 2)
OUTPUT
[1] 3.14Et si vous nommez les arguments, vous pouvez en changer l’ordre :
R
round(digits = 2, x = 3.14159)
OUTPUT
[1] 3.14Il est recommandé de placer les arguments obligatoires (comme le nombre que vous arrondissez) en premier dans votre appel de fonction, et de spécifier le nom de tous les arguments optionnels. Sinon, quelqu’un lisant votre code pourrait devoir consulter la définition d’une fonction présentant des arguments inconnus pour comprendre ce que vous faites. En spécifiant le nom des arguments, vous vous préservez également contre d’éventuels changements futurs de l’interface de la fonction, qui pourraient potentiellement ajouter de nouveaux arguments entre ceux existants.
Vecteurs et types de données
Un vecteur est le type de données le plus courant et le plus basique
dans R, et constitue pratiquement l’outil de base de R. Un vecteur est
composé d’une série de valeurs, telles que des nombres ou des
caractères. Nous pouvons attribuer une série de valeurs à un vecteur à
l’aide de la fonction c(). Par exemple, nous pouvons créer
un vecteur de poids d’animaux et l’attribuer à un nouvel objet
weight_g :
R
weight_g <- c(50, 60, 65, 82)
weight_g
OUTPUT
[1] 50 60 65 82Un vecteur peut également contenir des caractères :
R
molecules <- c("dna", "rna", "protein")
molecules
OUTPUT
[1] "dna" "rna" "protein"Les guillemets autour de « dna », « rna », etc., sont indispensables
ici. Sans les guillemets, R supposera qu’il existe des objets nommés
dna, rna et protein. Comme ces
objets n’existent pas dans la mémoire de R, un message d’erreur
s’affichera.
Il existe de nombreuses fonctions qui vous permettent d’examiner le
contenu d’un vecteur. length() vous indique combien
d’éléments se trouvent dans un vecteur particulier :
R
length(weight_g)
OUTPUT
[1] 4R
length(molecules)
OUTPUT
[1] 3Une caractéristique importante d’un vecteur est que tous ses éléments
sont du même type de données. La fonction class() indique
la classe (le type d’élément) d’un objet :
R
class(weight_g)
OUTPUT
[1] "numeric"R
class(molecules)
OUTPUT
[1] "character"La fonction str() fournit un aperçu de la structure d’un
objet et de ses éléments. C’est une fonction utile lorsque l’on
travaille avec des objets volumineux et complexes :
R
str(weight_g)
OUTPUT
num [1:4] 50 60 65 82R
str(molecules)
OUTPUT
chr [1:3] "dna" "rna" "protein"Vous pouvez utiliser la fonction c() pour ajouter
d’autres éléments à votre vecteur :
R
weight_g <- c(weight_g, 90) # add to the end of the vector
weight_g <- c(30, weight_g) # add to the beginning of the vector
weight_g
OUTPUT
[1] 30 50 60 65 82 90Dans la première ligne, nous prenons le vecteur d’origine
weight_g, ajoutons la valeur 90 à sa fin et
enregistrons le résultat dans weight_g. Ensuite, nous
ajoutons la valeur 30 au début, enregistrant à nouveau le
résultat dans weight_g.
Nous pouvons répéter cette opération à plusieurs reprises pour agrandir un vecteur ou assembler un jeu de données. Lors de la programmation, cela peut s’avérer utile pour ajouter des résultats que nous recueillons ou calculons.
Un vecteur atomique est le type de
données R le plus simple et constitue un vecteur linéaire d’un
seul type. Plus haut, nous avons vu 2 des 6 principaux types de
vecteurs atomiques utilisés par R :
"character" et "numeric" (ou
"double"). Ce sont les éléments de base à partir desquels
sont construits tous les objets R. Les 4 autres types de
vecteurs atomiques sont :
-
"logical"pourTRUEetFALSE(le type de données booléen) -
"integer"pour les nombres entiers (par ex.,2L, leLindique à R qu’il s’agit d’un nombre entier) -
"complex"pour représenter des nombres complexes avec partie réelle et partie imaginaire (par ex.,1 + 4i) et c’est tout ce que nous allons dire à leur sujet -
"raw"pour les flux binaires dont nous ne parlerons pas davantage
Vous pouvez vérifier le type de votre vecteur en utilisant la
fonction typeof() et en saisissant votre vecteur comme
argument.
Les vecteurs sont l’une des nombreuses structures de
données utilisées par R. Parmi les autres structures
importantes figurent les listes (list), les matrices
(matrix), les tableaux de données
(data.frame), les facteurs (factor) et les
tableaux (array).
Défi :
Nous avons vu que les vecteurs atomiques peuvent être de type caractère, numérique (ou double), entier et logique. Mais qu’arrive-t-il si nous essayons de mélanger ces types dans un seul vecteur ?
R les convertit implicitement tous au même type
Défi :
Qu’arrivera-t-il dans chacun de ces exemples ? (indice : utilisez
class() pour vérifier le type de données de vos objets et
saisissez leurs noms pour voir ce qui se passe) :
R
num_char <- c(1, 2, 3, "a")
num_logical <- c(1, 2, 3, TRUE, FALSE)
char_logical <- c("a", "b", "c", TRUE)
tricky <- c(1, 2, 3, "4")
R
class(num_char)
OUTPUT
[1] "character"R
num_char
OUTPUT
[1] "1" "2" "3" "a"R
class(num_logical)
OUTPUT
[1] "numeric"R
num_logical
OUTPUT
[1] 1 2 3 1 0R
class(char_logical)
OUTPUT
[1] "character"R
char_logical
OUTPUT
[1] "a" "b" "c" "TRUE"R
class(tricky)
OUTPUT
[1] "character"R
tricky
OUTPUT
[1] "1" "2" "3" "4"Défi :
Pourquoi pensez-vous que cela se produit ?
Les vecteurs ne peuvent contenir qu’un seul type de données. R tente de convertir le contenu de ce vecteur afin de trouver un dénominateur commun qui ne perde aucune information.
Défi :
Combien de valeurs dans combined_logical sont
"TRUE" (en tant que caractère) dans l’exemple suivant :
R
num_logical <- c(1, 2, 3, TRUE)
char_logical <- c("a", "b", "c", TRUE)
combined_logical <- c(num_logical, char_logical)
Un seul. Il n’y a aucune mémoire des types de données antérieurs, et
la coercition s’effectue la première fois que le vecteur est évalué. Par
conséquent, le TRUE dans num_logical est
converti en 1 avant d’être converti en "1"
dans combined_logical.
R
combined_logical
OUTPUT
[1] "1" "2" "3" "1" "a" "b" "c" "TRUE"Défi :
En R, nous appelons coercion la conversion d’objets d’une classe à une autre. Ces conversions s’effectuent selon une hiérarchie, selon laquelle certains types sont prioritairement convertis en d’autres. Pouvez-vous tracer un schéma représentant la hiérarchie de la manière dont ces types de données sont convertis ?
logique → numérique → caractère ← logique
Extraction de sous-ensembles de vecteurs
Si nous souhaitons extraire une ou plusieurs valeurs d’un vecteur, nous devons fournir un ou plusieurs indices entre crochets. Par exemple :
R
molecules <- c("dna", "rna", "peptide", "protein")
molecules[2]
OUTPUT
[1] "rna"R
molecules[c(3, 2)]
OUTPUT
[1] "peptide" "rna" Nous pouvons également répéter les indices pour créer un objet comportant plus d’éléments que l’original :
R
more_molecules <- molecules[c(1, 2, 3, 2, 1, 4)]
more_molecules
OUTPUT
[1] "dna" "rna" "peptide" "rna" "dna" "protein"Les indices en R commencent à 1. Les langages de programmation tels que Fortran, MATLAB, Julia et R commencent à compter à partir de 1, car c’est ainsi que les êtres humains le font habituellement. Les langages de la famille C (y compris C++, Java, Perl et Python) comptent à partir de 0, car c’est plus simple pour les ordinateurs.
Enfin, il est également possible d’obtenir tous les éléments d’un vecteur, à l’exception de certains éléments spécifiés, en utilisant des indices négatifs :
R
molecules ## all molecules
OUTPUT
[1] "dna" "rna" "peptide" "protein"R
molecules[-1] ## all but the first one
OUTPUT
[1] "rna" "peptide" "protein"R
molecules[-c(1, 3)] ## all but 1st/3rd ones
OUTPUT
[1] "rna" "protein"R
molecules[c(-1, -3)] ## all but 1st/3rd ones
OUTPUT
[1] "rna" "protein"Sélection conditionnelle d’éléments
Une autre façon courante de sélectionner un sous-ensemble consiste à
utiliser un vecteur logique. TRUE sélectionnera l’élément
ayant le même indice, tandis que FALSE ne le sélectionnera
pas :
R
weight_g <- c(21, 34, 39, 54, 55)
weight_g[c(TRUE, FALSE, TRUE, TRUE, FALSE)]
OUTPUT
[1] 21 39 54En général, ces vecteurs logiques ne sont pas saisis manuellement, mais sont le résultat d’autres fonctions ou de tests logiques. Par exemple, si vous souhaitiez sélectionner uniquement les valeurs supérieures à 50 :
R
## will return logicals with TRUE for the indices that meet
## the condition
weight_g > 50
OUTPUT
[1] FALSE FALSE FALSE TRUE TRUER
## so we can use this to select only the values above 50
weight_g[weight_g > 50]
OUTPUT
[1] 54 55Vous pouvez combiner plusieurs tests à l’aide de &
(les deux conditions sont vraies, ET) ou de | (au moins
l’une des conditions est vraie, OU) :
R
weight_g[weight_g < 30 | weight_g > 50]
OUTPUT
[1] 21 54 55R
weight_g[weight_g >= 30 & weight_g == 21]
OUTPUT
numeric(0)Ici, < désigne « inférieur à », > «
supérieur à », >= « supérieur ou égal à » et
== « égal à ». Le double signe égal == est une
opération de vérification de l’égalité numérique entre le membre de
gauche et celui de droite, et ne doit pas être confondu avec le signe
unique =, qui effectue l’affectation d’une variable (à
l’instar de <-).
Une tâche courante consiste à rechercher certaines chaînes de
caractères dans un vecteur. On pourrait utiliser l’opérateur « ou »
| pour vérifier l’égalité avec plusieurs valeurs, mais cela
peut rapidement devenir fastidieux. La fonction %in% permet
de vérifier si l’un des éléments d’un vecteur de recherche est trouvé
:
R
molecules <- c("dna", "rna", "protein", "peptide")
molecules[molecules == "rna" | molecules == "dna"] # returns both rna and dna
OUTPUT
[1] "dna" "rna"R
molecules %in% c("rna", "dna", "metabolite", "peptide", "glycerol")
OUTPUT
[1] TRUE TRUE FALSE TRUER
molecules[molecules %in% c("rna", "dna", "metabolite", "peptide", "glycerol")]
OUTPUT
[1] "dna" "rna" "peptide"Défi :
Parvenez-vous à comprendre pourquoi "four" > "five"
renvoie TRUE ?
R
"four" > "five"
OUTPUT
[1] TRUELorsqu’on utilise > ou < sur des
chaînes de caractères, R compare leur ordre alphabétique. Ici,
"four" vient après "five" et lui est donc
supérieur.
Noms
Il est possible de nommer chaque élément d’un vecteur. Le bloc de code ci-dessous montre un vecteur initial sans aucun nom, ainsi que la manière dont les noms sont définis et récupérés.
R
x <- c(1, 5, 3, 5, 10)
names(x) ## no names
OUTPUT
NULLR
names(x) <- c("A", "B", "C", "D", "E")
names(x) ## now we have names
OUTPUT
[1] "A" "B" "C" "D" "E"Lorsqu’un vecteur possède des noms, il est possible d’accéder aux éléments par leur nom, en plus de leur index.
R
x[c(1, 3)]
OUTPUT
A C
1 3 R
x[c("A", "C")]
OUTPUT
A C
1 3 Données manquantes
Comme R a été conçu pour analyser des jeux de données, il inclut le
concept de données manquantes (ce qui est rare dans d’autres langages de
programmation). Les données manquantes sont représentées dans les
vecteurs par NA.
Lorsque vous effectuez des opérations sur des nombres, la plupart des
fonctions renvoient NA si les données avec lesquelles vous
travaillez contiennent des valeurs manquantes. Cette fonctionnalité rend
plus difficile le fait de négliger les cas où vous manipulez des données
manquantes. Vous pouvez ajouter l’argument na.rm = TRUE
pour calculer le résultat tout en ignorant les valeurs manquantes.
R
heights <- c(2, 4, 4, NA, 6)
mean(heights)
OUTPUT
[1] NAR
max(heights)
OUTPUT
[1] NAR
mean(heights, na.rm = TRUE)
OUTPUT
[1] 4R
max(heights, na.rm = TRUE)
OUTPUT
[1] 6Si vos données contiennent des valeurs manquantes, vous souhaiterez
peut-être vous familiariser avec les fonctions is.na(),
na.omit() et complete.cases(). Consultez les
exemples ci-dessous.
R
## Extract those elements which are not missing values.
heights[!is.na(heights)]
OUTPUT
[1] 2 4 4 6R
## Returns the object with incomplete cases removed.
## The returned object is an atomic vector of type `"numeric"`
## (or `"double"`).
na.omit(heights)
OUTPUT
[1] 2 4 4 6
attr(,"na.action")
[1] 4
attr(,"class")
[1] "omit"R
## Extract those elements which are complete cases.
## The returned object is an atomic vector of type `"numeric"`
## (or `"double"`).
heights[complete.cases(heights)]
OUTPUT
[1] 2 4 4 6Défi :
- À l’aide de ce vecteur de tailles en pouces, créez un nouveau vecteur dont les valeurs NA ont été supprimées.
R
heights <- c(63, 69, 60, 65, NA, 68, 61, 70, 61, 59, 64, 69, 63, 63, NA, 72, 65, 64, 70, 63, 65)
- Utilisez la fonction
median()pour calculer la médiane du vecteurheights. - Utilisez R pour déterminer combien de personnes dans l’ensemble mesurent plus de 67 pouces.
R
heights_no_na <- heights[!is.na(heights)]
## or
heights_no_na <- na.omit(heights)
R
median(heights, na.rm = TRUE)
OUTPUT
[1] 64R
heights_above_67 <- heights_no_na[heights_no_na > 67]
length(heights_above_67)
OUTPUT
[1] 6Génération de vecteurs
Constructeurs
Il existe plusieurs fonctions permettant de générer des vecteurs de
différents types. Pour générer un vecteur de nombres, on peut utiliser
le constructeur numeric(), en fournissant la longueur du
vecteur de sortie comme paramètre. Les valeurs seront initialisées à
0.
R
numeric(3)
OUTPUT
[1] 0 0 0R
numeric(10)
OUTPUT
[1] 0 0 0 0 0 0 0 0 0 0Notons que si nous demandons un vecteur numérique de longueur 0, nous obtenons exactement cela :
R
numeric(0)
OUTPUT
numeric(0)Il existe des constructeurs similaires pour les caractères et les
valeurs logiques, nommés respectivement character() et
logical().
Défi :
Quelles sont les valeurs par défaut pour les vecteurs de caractères et logiques ?
R
character(2) ## the empty character
OUTPUT
[1] "" ""R
logical(2) ## FALSE
OUTPUT
[1] FALSE FALSERépliquer des éléments
La fonction rep permet de répéter une valeur un certain
nombre de fois. Si nous souhaitons initialiser un vecteur numérique de
longueur 5 avec la valeur -1, par exemple, nous pourrions procéder comme
suit :
R
rep(-1, 5)
OUTPUT
[1] -1 -1 -1 -1 -1De même, pour générer un vecteur rempli de valeurs manquantes, ce qui constitue souvent un bon point de départ, sans formuler d’hypothèses sur les données à collecter :
R
rep(NA, 5)
OUTPUT
[1] NA NA NA NA NArep peut accepter en entrée des vecteurs de longueur
quelconque (ci-dessus, nous avons utilisé des vecteurs de longueur 1) et
de tout type. Par exemple, si nous voulons répéter les valeurs 1, 2 et 3
cinq fois, nous procéderions comme suit :
R
rep(c(1, 2, 3), 5)
OUTPUT
[1] 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3Défi :
Et si nous voulions répéter les valeurs 1, 2 et 3 cinq fois, mais
obtenir cinq 1, cinq 2 et cinq 3 dans cet ordre ? Il existe deux
possibilités — consultez ?rep ou ?sort pour
obtenir de l’aide.
R
rep(c(1, 2, 3), each = 5)
OUTPUT
[1] 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3R
sort(rep(c(1, 2, 3), 5))
OUTPUT
[1] 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3Génération de séquences
Une autre fonction très utile est seq, pour générer une
suite de nombres. Par exemple, pour générer une suite d’entiers de 1 à
20 par paliers de 2, on utiliserait :
R
seq(from = 1, to = 20, by = 2)
OUTPUT
[1] 1 3 5 7 9 11 13 15 17 19La valeur par défaut de by est 1 et, étant donné que la
génération d’une suite allant d’une valeur à une autre par paliers de 1
est fréquemment utilisée, il existe un raccourci :
R
seq(1, 5, 1)
OUTPUT
[1] 1 2 3 4 5R
seq(1, 5) ## default by
OUTPUT
[1] 1 2 3 4 5R
1:5
OUTPUT
[1] 1 2 3 4 5Pour générer une suite de nombres de 1 à 20 d’une longueur finale de 3, on utiliserait :
R
seq(from = 1, to = 20, length.out = 3)
OUTPUT
[1] 1.0 10.5 20.0Échantillons aléatoires et permutations
Un dernier groupe de fonctions utiles consiste à génèrer des données
aléatoires. La première, sample, génère une permutation
aléatoire d’un autre vecteur. Par exemple, pour établir un ordre
aléatoire pour l’examen oral de 10 étudiants, j’attribue d’abord à
chaque étudiant un numéro de 1 à 10 (par exemple, selon l’ordre
alphabétique de son nom) puis :
R
sample(1:10)
OUTPUT
[1] 9 4 7 1 2 5 3 10 6 8Sans arguments supplémentaires, sample renvoie une
permutation de tous les éléments du vecteur. Si je souhaite un
échantillon aléatoire d’une certaine taille, je définirais cette valeur
comme second argument. Ci-dessous, je tire 5 lettres aléatoires de
l’alphabet contenu dans le vecteur letters prédéfini :
R
sample(letters, 5)
OUTPUT
[1] "s" "a" "u" "x" "j"Si je souhaitais obtenir un échantillon plus long que le vecteur
d’entrée, ou pouvoir tirer certains éléments plusieurs fois, je devrais
fixer l’argument replace à TRUE :
R
sample(1:5, 10, replace = TRUE)
OUTPUT
[1] 2 1 5 5 1 1 5 5 2 2Défi :
En essayant les fonctions ci-dessus, vous aurez constaté que les
échantillons sont effectivement aléatoires et qu’on n’obtient pas la
même permutation deux fois. Pour pouvoir reproduire ces tirages
aléatoires, on peut définir manuellement la graine de génération de
nombres aléatoires avec set.seed() avant de tirer
l’échantillon aléatoire.
Testez cette fonctionnalité avec votre voisin. Tirez d’abord deux
permutations aléatoires de 1:10 indépendamment et observez
que vous obtenez des résultats différents.
Définissez maintenant la graine avec, par exemple,
set.seed(123) et répétez l’échantillonnage aléatoire.
Observez que vous obtenez désormais les mêmes échantillonnages
aléatoires.
Répétez l’opération en définissant une graine différente.
Différentes permutations
R
sample(1:10)
OUTPUT
[1] 9 1 4 3 6 2 5 8 10 7R
sample(1:10)
OUTPUT
[1] 4 9 7 6 1 10 8 3 2 5Mêmes permutations avec la graine 123
R
set.seed(123)
sample(1:10)
OUTPUT
[1] 3 10 2 8 6 9 1 7 5 4R
set.seed(123)
sample(1:10)
OUTPUT
[1] 3 10 2 8 6 9 1 7 5 4Une graine différente
R
set.seed(1)
sample(1:10)
OUTPUT
[1] 9 4 7 1 2 5 3 10 6 8R
set.seed(1)
sample(1:10)
OUTPUT
[1] 9 4 7 1 2 5 3 10 6 8Tirage d’échantillons à partir d’une distribution normale
La dernière fonction que nous allons voir est rnorm, qui
tire un échantillon aléatoire d’une distribution normale. Deux
distributions normales dont les moyennes sont 0 et 100 et les
écarts-types 1 et 5, notées N(0, 1) et N(100, 5), sont
illustrées ci-dessous.
Les trois arguments, n, mean et
sd, définissent la taille de l’échantillon ainsi que les
paramètres de la distribution normale, à savoir sa moyenne et son
écart-type. Les valeurs par défaut de la moyenne et de l’écart-type sont
respectivement 0 et 1.
R
rnorm(5)
OUTPUT
[1] 0.69641761 0.05351568 -1.31028350 -2.12306606 -0.20807859R
rnorm(5, 2, 2)
OUTPUT
[1] 1.3744268 -0.1164714 2.8344472 1.3690969 3.6510983R
rnorm(5, 100, 5)
OUTPUT
[1] 106.45636 96.87448 95.62427 100.71678 107.12595Maintenant que nous avons appris à écrire des scripts et les bases des structures de données de R, nous sommes prêts à commencer à travailler avec des données plus volumineuses et à découvrir les tableaux de données.
- Comment interagir avec R