Introduction à R

Dernière mise à jour le 2024-09-12 | Modifier cette page

Vue d'ensemble

Questions

  • Premières commandes dans R

Objectifs

  • Définissez les termes suivants relatifs à R : objet, affectation, appel, fonction, arguments, options.
  • Attribuez des valeurs aux objets dans R.
  • Apprenez à nommer des objets
  • Utilisez les commentaires pour informer le script.
  • Résoudre des opérations arithmétiques simples dans R.
  • Appelez des fonctions et utilisez des arguments pour modifier leurs options par défaut.
  • Inspectez le contenu des vecteurs et manipulez leur contenu.
  • Sous-ensembler et extraire des valeurs à partir de vecteurs.
  • Analysez les vecteurs avec des données manquantes.

Cet épisode est basé sur la leçon Analyse des données et Visualisation dans R pour les écologistes de Data Carpentries.

Créer des objets dans R

Vous pouvez obtenir le résultat de R simplement en tapant math dans la console :

R 

3 + 5

SORTIE 

[1] 8

R 

12 / 7

SORTIE 

[1] 1.714286

Cependant, pour faire des choses utiles et intéressantes, nous devons attribuer des valeurs à objets. Pour créer un objet, nous devons lui donner un nom suivi de l’opérateur d’affectation <-, et de la valeur que nous voulons lui donner :

R 

poids_kg <- 55

<- est l’opérateur d’affectation. Il attribue des valeurs à droite aux objets à gauche. Ainsi, après avoir exécuté x <- 3, la valeur de x est 3. La flèche peut être lue comme 3 entre dans x. Pour des raisons historiques , vous pouvez également utiliser = pour les affectations, mais pas dans tous les contextes . En raison du légères différences dans la syntaxe, il est une bonne pratique de toujours utiliser <- pour les affectations.

In RStudio, typing Alt + - (push Alt at the same time as the - key) will write <- in a single keystroke in a PC, while typing Option + - (push Option at the same time as the - key) does the same in a Mac.

Nommer les variables

Les objets peuvent recevoir n’importe quel nom tel que « x », « current_temperature » ou « subject_id ». Vous voulez que les noms de vos objets soient explicites et pas trop longs. Ils ne peuvent pas commencer par un nombre (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 sont les noms de fonctions fondamentales dans R (par exemple, if, else, for, voir ici pour une liste complète). En général, même si c’est autorisé, il est préférable de de ne pas utiliser d’autres noms de fonctions (par exemple, c, T, mean, data, df, poids). 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 (.) dans un nom d’objet comme dans my.dataset. There are many functions in R with dots in their names for historical reasons, but because dots have a special meaning in R (for methods) and other programming languages, it’s best to avoid them. Il est également recommandé d’utiliser des noms pour les noms d’objets et des verbes pour les noms de fonctions. Il est important d’être cohérent dans le style de votre code (où vous placez les espaces, comment vous nommez les objets, etc.). L’utilisation d’un style de codage cohérent rend votre code plus clair à lire pour votre futur moi et vos collaborateurs. Dans R, certains guides de style populaires sont de Google, le tidyverse et le Bioconductor style guide. Le Tidyverse est très complet et peut sembler écrasant au début . Vous pouvez installer le package lintr pour vérifier automatiquement les problèmes dans le style de votre code.

Objets et variables : ce que l’on appelle des « objets » dans « R » sont connus sous le nom de « variables » dans de nombreux autres langages de programmation. Selon le contexte, « objet » et « variable » peuvent avoir des significations radicalement différentes. Cependant, dans cette leçon, les deux mots sont utilisés de manière synonyme. Pour plus d’informations voir ici.

Lors de l’attribution d’une valeur à un objet, R n’imprime rien. Vous pouvez forcer R à imprimer la valeur en utilisant des parenthèses ou en tapant le nom de l’objet :

R 

weight_kg <- 55 # n'imprime rien
(weight_kg <- 55) # mais mettre des parenthèses autour de l'appel imprime la valeur de `weight_kg`

SORTIE 

[1] 55

R 

weight_kg # et taper également le nom du objet

SORTIE 

[1] 55

Maintenant que R a « weight_kg » en mémoire, nous pouvons faire de l’arithmétique avec. Pour exemple, nous pouvons vouloir convertir ce poids en livres (le poids en livres est 2,2 fois le poids en kg) :

R 

2.2 * weight_kg

SORTIE 

[1] 121

On peut également changer la valeur d’un objet en lui attribuant une nouvelle :

R 

weight_kg <- 57.5
2.2 * weight_kg

SORTIE 

[1] 126.5

Cela signifie que l’attribution d’une valeur à un objet ne modifie pas les valeurs de 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 remplacez « weight_kg » par 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 décommenter facilement un paragraphe : après sélectionnant les lignes que vous souhaitez commenter, appuyez en même temps sur votre clavier Ctrl + Maj + C. If you only want to comment out one line, you can put the cursor at any location of that line (i.e. no need to select the whole line), then press Ctrl + Shift + C.

Défi

Quelles sont les valeurs après chaque instruction suivante ?

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édéfinis” qui automatisent des ensembles de commandes plus complexes , y compris les affectations d’opérations, etc. De nombreuses fonctions sont prédéfinies ou peuvent être rendues disponibles en important des packages R (nous en parlerons plus tard). Une fonction obtient généralement une ou plusieurs entrées appelées arguments. Les fonctions renvoient souvent (mais pas toujours) une valeur. Un exemple typique 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. Exécuter une fonction (« l’exécuter ») est appelé appeler la fonction. Un exemple d’appel de fonction est :

R 

b <- sqrt(a)

Ici, la valeur de a est donnée à la fonction sqrt(), la fonction sqrt() calcule la racine carrée, et renvoie la valeur qui est ensuite attribuée à l’objet ‘b’. Cette fonction est très simple car elle ne prend qu’un seul argument.

The return ‘value’ of a function need not be numerical (like that of sqrt()), and it also does not need to be a single item: it can be a set of things, or even a dataset. Nous le verrons lorsque nous lirons des fichiers de données dans R.

Les arguments peuvent être n’importe quoi, non seulement des nombres ou des noms de fichiers, mais aussi d’autres objets . La signification exacte de chaque argument diffère selon la fonction et doit être recherchée dans la documentation (voir ci-dessous). Certaines fonctions prennent des arguments qui peuvent soit être spécifiés par l’utilisateur, soit, s’ils sont laissés de côté, prendre une valeur par défaut : ceux-ci sont appelés options. Les options sont généralement utilisées pour modifier le fonctionnement de la fonction , par exemple si elle ignore les « mauvaises valeurs » ou quel symbole utiliser dans un tracé. 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 qui peut prendre plusieurs arguments : round().

R 

round(3.14159)

SORTIE 

[1] 3

Ici, nous avons appelé round() avec un seul argument, 3.14159, et il a renvoyé la valeur 3. En effet, la valeur par défaut est d’arrondir au nombre entier le plus proche. Si nous voulons plus de chiffres, nous pouvons voir comment procéder en obtenant des informations sur la fonction round. Nous pouvons utiliser args(round) ou consulter l’aide pour cette fonction en utilisant ?round.

R 

args(round)

SORTIE 

function (x, digits = 0, ...)
NULL

R 

?round

Nous voyons que si nous voulons un nombre différent de chiffres, nous pouvons taper digits=2 ou autant que nous le voulons.

R 

round(3.14159, digits = 2)

SORTIE 

[1] 3.14

Si vous fournissez les arguments exactement dans le même ordre que celui dans lequel ils sont définis, vous n’avez pas besoin de les nommer :

R 

round(3.14159, 2)

SORTIE 

[1] 3.14

Et si vous nommez les arguments, vous pouvez changer leur ordre :

R 

round(digits = 2, x = 3.14159)

SORTIE 

[1] 3.14

Il est recommandé de placer les arguments non facultatifs (comme le nombre que vous arrondissez ) en premier dans votre appel de fonction et de spécifier les noms de tous les arguments facultatifs. Si vous ne le faites pas, quelqu’un qui lit votre code devra peut-être rechercher la définition d’une fonction avec des arguments inconnus pour comprendre ce que vous faites . En spécifiant le nom des arguments, vous protégez également contre d’éventuelles modifications futures dans l’interface de la fonction, qui peuvent 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 est à peu près le cheval de bataille de R. Un vecteur est composé d’une série de valeurs, telles que nombres ou caractères. Nous pouvons attribuer une série de valeurs à un vecteur en utilisant 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

SORTIE 

[1] 50 60 65 82

Un vecteur peut également contenir des caractères :

R 

molecules <- c("dna", "rna", "protein")
molecules

SORTIE 

[1] "dna"     "rna"     "protein"

Les guillemets autour de « adn », « arn », etc. sont ici essentiels. Sans les guillemets , R supposera qu’il existe des objets appelés « adn », « arn » et « protéine ». Comme ces objets n’existent pas dans la mémoire de R, il y aura un message d’erreur.

Il existe de nombreuses fonctions qui vous permettent d’inspecter le contenu d’un vecteur . length() vous indique combien d’éléments se trouvent dans un vecteur particulier :

R 

length(weight_g)

SORTIE 

[1] 4

R 

length(molecules)

SORTIE 

[1] 3

Une caractéristique importante d’un vecteur est que tous les é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)

SORTIE 

[1] "numeric"

R 

class(molecules)

SORTIE 

[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 vous travaillez avec des objets volumineux et complexes :

R 

str(weight_g)

SORTIE 

 num [1:4] 50 60 65 82

R 

str(molecules)

SORTIE 

 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

SORTIE 

[1] 30 50 60 65 82 90

Dans la première ligne, nous prenons le vecteur d’origine weight_g, ajoutons la valeur 90 à la fin de celui-ci et enregistrons le résultat dans weight_g. Ensuite, nous ajoutons la valeur « 30 » au début, en enregistrant à nouveau le résultat dans « weight_g ».

Nous pouvons faire cela encore et encore pour développer un vecteur ou assembler un ensemble de données . Au fur et à mesure que nous programmons, cela peut être utile pour ajouter les résultats que nous collectons ou calculons.

Un vecteur atomique est le type de données R le plus simple et est un vecteur linéaire d’un seul type. Ci-dessus, nous avons vu 2 des 6 principaux types de vecteurs **atomiques ** que R utilise : "caractère" et "numérique" (ou "double"). Ce sont les éléments de base à partir desquels tous les objets R sont construits. Les 4 autres types de vecteurs atomiques sont :

  • "logique" pour TRUE et FALSE (le type de données booléen)
  • "integer" pour les nombres entiers (par exemple, 2L, le L indique à R que c’est un entier)
  • "complexe" pour représenter des nombres complexes avec des parties réelles et imaginaires (par exemple, 1 + 4i) et c’est tout ce que nous allons dire à leur sujet
  • "raw" pour les bitstreams 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. Les autres importants sont les listes (list), les matrices (matrix), les trames 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 que se passe-t-il si nous essayons de mélanger ces types dans un seul vecteur ?

R les convertit implicitement pour qu’ils soient tous du même type

Défi:

Que se passera-t-il dans chacun de ces exemples ? (indice : utilisez class() pour vérifier le type de données de vos objets et tapez 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)

SORTIE 

[1] "character"

R 

num_char

SORTIE 

[1] "1" "2" "3" "a"

R 

class(num_logical)

SORTIE 

[1] "numeric"

R 

num_logical

SORTIE 

[1] 1 2 3 1 0

R 

class(char_logical)

SORTIE 

[1] "character"

R 

char_logical

SORTIE 

[1] "a"    "b"    "c"    "TRUE"

R 

class(tricky)

SORTIE 

[1] "character"

R 

tricky

SORTIE 

[1] "1" "2" "3" "4"

Défi:

Pourquoi pensez-vous que cela arrive ?

Les vecteurs ne peuvent appartenir qu’à un seul type de données. R essaie de convertir (contraindre) le contenu de ce vecteur pour trouver un dénominateur commun qui ne perd aucune information.

Défi:

Combien de valeurs dans combined_logical sont "TRUE" (sous forme de 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)

Seulement un. Il n’y a pas de mémoire des types de données passés et la coercition se produit 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

SORTIE 

[1] "1"    "2"    "3"    "1"    "a"    "b"    "c"    "TRUE"

Défi:

Dans R, nous appelons la conversion d’objets d’une classe vers une autre classe coercition. Ces conversions se produisent selon une hiérarchie, selon laquelle certains types sont préférentiellement contraints vers d’autres types. Pouvez-vous dessiner un diagramme qui représente la hiérarchie de la façon dont ces types de données sont forcés ?

logique → numérique → caractère ← logique

Vecteurs de sous-ensemble

Si l’on veut extraire une ou plusieurs valeurs d’un vecteur, il faut fournir un ou plusieurs indices entre crochets. Par exemple:

R 

molecules <- c("dna", "rna", "peptide", "protein")
molecules[2]

SORTIE 

[1] "rna"

R 

molecules[c(3, 2)]

SORTIE 

[1] "peptide" "rna"

On peut également répéter les indices pour créer un objet avec plus d’éléments que celui d’origine :

R 

more_molecules <- molecules[c(1, 2, 3, 2, 1, 4)]
more_molecules

SORTIE 

[1] "dna"     "rna"     "peptide" "rna"     "dna"     "protein"

Les indices R commencent à 1. Les langages de programmation comme Fortran, MATLAB, Julia et R commencent à compter à 1, car c’est ce que font généralement les êtres humains . Les langages de la famille C (y compris C++, Java, Perl, et Python) comptent à partir de 0 car c’est plus simple à faire pour les ordinateurs.

Enfin, il est également possible d’obtenir tous les éléments d’un vecteur sauf certains éléments spécifiés en utilisant des indices négatifs :

R 

molecules ## all molecules

SORTIE 

[1] "dna"     "rna"     "peptide" "protein"

R 

molecules[-1] ## all but the first one

SORTIE 

[1] "rna"     "peptide" "protein"

R 

molecules[-c(1, 3)] ## all but 1st/3rd ones

SORTIE 

[1] "rna"     "protein"

R 

molecules[c(-1, -3)] ## all but 1st/3rd ones

SORTIE 

[1] "rna"     "protein"

Sous-ensemble conditionnel

Une autre méthode courante de sous-ensemble consiste à utiliser un vecteur logique. TRUE sélectionnera l’élément avec le même index, tandis que FALSE ne le fera pas :

R 

weight_g <- c(21, 34, 39, 54, 55)
weight_g[c(TRUE, FALSE, TRUE, TRUE, FALSE)]

SORTIE 

[1] 21 39 54

Généralement, ces vecteurs logiques ne sont pas tapés à la main, mais sont la sortie d’autres fonctions ou tests logiques. Par exemple, si vous souhaitez sélectionner uniquement les valeurs supérieures à 50 :

R 

## will return logicals with TRUE for the indices that meet
## the condition
weight_g > 50

SORTIE 

[1] FALSE FALSE FALSE  TRUE  TRUE

R 

## so we can use this to select only the values above 50
weight_g[weight_g > 50]

SORTIE 

[1] 54 55

Vous pouvez combiner plusieurs tests en utilisant & (les deux conditions sont vraies, AND) ou | (au moins une des conditions est vraie, OR) :

R 

weight_g[weight_g < 30 | weight_g > 50]

SORTIE 

[1] 21 54 55

R 

weight_g[weight_g >= 30 & weight_g == 21]

SORTIE 

numeric(0)

Ici, < signifie “inférieur à”, > pour “supérieur à”, >= pour “supérieur ou égal à” et == pour “égal à”. The double equal sign == is a test for numerical equality between the left and right hand sides, and should not be confused with the single = sign, which performs variable assignment (similar to <-).

Une tâche courante consiste à rechercher certaines chaînes dans un vecteur. On pourrait utiliser l’opérateur “ou” | pour tester l’égalité de plusieurs valeurs, mais cela peut rapidement devenir fastidieux. La fonction %in% permet de tester 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

SORTIE 

[1] "dna" "rna"

R 

molecules %in% c("rna", "dna", "metabolite", "peptide", "glycerol")

SORTIE 

[1]  TRUE  TRUE FALSE  TRUE

R 

molecules[molecules %in% c("rna", "dna", "metabolite", "peptide", "glycerol")]

SORTIE 

[1] "dna"     "rna"     "peptide"

Défi:

Pouvez-vous comprendre pourquoi « quatre » > « cinq » renvoie « VRAI » ?

R 

"four" > "five"

SORTIE 

[1] TRUE

Lorsque vous utilisez > ou < sur des chaînes, R compare leur ordre alphabétique. Ici, "quatre" vient après "cinq", et est donc supérieur à .

Des noms

Il est possible de nommer chaque élément d’un vecteur. Le morceau de code ci-dessous montre un vecteur initial sans aucun nom, comment les noms sont définis et récupérés.

R 

x <- c(1, 5, 3, 5, 10)
names(x) ## no names

SORTIE 

NULL

R 

names(x) <- c("A", "B", "C", "D", "E")
names(x) ## now we have names

SORTIE 

[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)]

SORTIE 

A C
1 3

R 

x[c("A", "C")]

SORTIE 

A C
1 3

Données manquantes

Comme R a été conçu pour analyser des ensembles 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 renverront « NA » si les données avec lesquelles vous travaillez incluent des valeurs manquantes. Cette fonctionnalité rend plus difficile l’ignorance des cas où vous avez affaire à données manquantes. Vous pouvez ajouter l’argument na.rm = TRUE pour calculer le résultat en ignorant les valeurs manquantes.

R 

heights <- c(2, 4, 4, NA, 6)
mean(heights)

SORTIE 

[1] NA

R 

max(heights)

SORTIE 

[1] NA

R 

mean(heights, na.rm = TRUE)

SORTIE 

[1] 4

R 

max(heights, na.rm = TRUE)

SORTIE 

[1] 6

Si vos données incluent des valeurs manquantes, vous souhaiterez peut-être vous familiariser avec les fonctions is.na(), na.omit() et complete.cases(). Voir ci-dessous pour des exemples.

R 

## Extract those elements which are not missing values.
heights[!is.na(heights)]

SORTIE 

[1] 2 4 4 6

R 

## Returns the object with incomplete cases removed.
## The returned object is an atomic vector of type `"numeric"`
## (or `"double"`).
na.omit(heights)

SORTIE 

[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)]

SORTIE 

[1] 2 4 4 6

Défi:

  1. En utilisant ce vecteur de hauteurs en pouces, créez un nouveau vecteur en supprimant les NA.

R 

heights <- c(63, 69, 60, 65, NA, 68, 61, 70, 61, 59, 64, 69, 63, 63, NA, 72, 65, 64, 70, 63, 65)
  1. Utilisez la fonction median() pour calculer la médiane du vecteur heights.
  2. 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)

SORTIE 

[1] 64

R 

heights_above_67 <- heights_no_na[heights_no_na > 67]
length(heights_above_67)

SORTIE 

[1] 6

Génération de vecteurs

Constructeurs

Il existe quelques fonctions pour générer des vecteurs de différents types. Pour générer un vecteur de valeurs numériques, on peut utiliser le constructeur numeric() , fournissant la longueur du vecteur de sortie comme paramètre . Les valeurs seront initialisées à 0.

R 

numeric(3)

SORTIE 

[1] 0 0 0

R 

numeric(10)

SORTIE 

 [1] 0 0 0 0 0 0 0 0 0 0

Notez que si l’on demande un vecteur de numériques de longueur 0, on obtient exactement cela :

R 

numeric(0)

SORTIE 

numeric(0)

Il existe des constructeurs similaires pour les caractères et les logiques, nommés respectivement character() et logical().

Défi:

Quelles sont les valeurs par défaut pour les caractères et les vecteurs logiques ?

R 

character(2) ## the empty character

SORTIE 

[1] "" ""

R 

logical(2)   ## FALSE

SORTIE 

[1] FALSE FALSE

Répliquer des éléments

La fonction rep permet de répéter une valeur un certain nombre de fois. Si nous voulons initier un vecteur de numériques de longueur 5 avec la valeur -1, par exemple, nous pourrions faire ce qui suit :

R 

rep(-1, 5)

SORTIE 

[1] -1 -1 -1 -1 -1

De même, pour générer un vecteur rempli de valeurs manquantes, ce qui est souvent une bonne façon de commencer, sans poser d’hypothèses sur les données à collecter :

R 

rep(NA, 5)

SORTIE 

[1] NA NA NA NA NA

rep peut prendre en entrée des vecteurs de n’importe quelle longueur (ci-dessus, nous avons utilisé des vecteurs de longueur 1) et de n’importe quel type. Par exemple, si nous voulons répéter cinq fois les valeurs 1, 2 et 3, nous procéderions comme suit :

R 

rep(c(1, 2, 3), 5)

SORTIE 

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

Défi:

Et si nous voulions répéter les valeurs 1, 2 et 3 cinq fois, mais que obtenait cinq 1, cinq 2 et cinq 3 dans cet ordre ? Il existe deux possibilités - voir ?rep ou ?sort pour obtenir de l’aide.

R 

rep(c(1, 2, 3), each = 5)

SORTIE 

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

R 

sort(rep(c(1, 2, 3), 5))

SORTIE 

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

Génération de séquence

Une autre fonction très utile est seq, pour générer une séquence de nombres. Par exemple, pour générer une séquence d’entiers de 1 à 20 par pas de 2, on utiliserait :

R 

seq(from = 1, to = 20, by = 2)

SORTIE 

 [1]  1  3  5  7  9 11 13 15 17 19

La valeur par défaut de by est 1 et, étant donné que la génération d’une séquence d’une valeur à une autre avec des pas de 1 est fréquemment utilisée, il existe un raccourci :

R 

seq(1, 5, 1)

SORTIE 

[1] 1 2 3 4 5

R 

seq(1, 5) ## default by

SORTIE 

[1] 1 2 3 4 5

R 

1:5

SORTIE 

[1] 1 2 3 4 5

Pour générer une séquence de nombres de 1 à 20 de longueur finale de 3, on utiliserait :

R 

seq(from = 1, to = 20, length.out = 3)

SORTIE 

[1]  1.0 10.5 20.0

Échantillons aléatoires et permutations

Un dernier groupe de fonctions utiles sont celles qui génèrent des données aléatoires . Le premier, sample, génère une permutation aléatoire de un autre vecteur. Par exemple, pour tirer au sort un ordre aléatoire de 10 étudiants à l’examen oral, j’attribue d’abord à chaque étudiant un numéro de 1 à dix (par exemple en fonction de l’ordre alphabétique de son nom) puis :

R 

sample(1:10)

SORTIE 

 [1]  9  4  7  1  2  5  3 10  6  8

Sans autres arguments, sample renverra une permutation de tous les éléments du vecteur. Si je veux un échantillon aléatoire d’une certaine taille, je définirais cette valeur comme deuxième argument. Ci-dessous, j’échantillonne 5 lettres aléatoires de l’alphabet contenu dans le vecteur letters prédéfini :

R 

sample(letters, 5)

SORTIE 

[1] "s" "a" "u" "x" "j"

Si je voulais une sortie plus grande que le vecteur d’entrée, ou pouvoir dessiner certains éléments plusieurs fois, je devrais définir l’argument replace sur TRUE :

R 

sample(1:5, 10, replace = TRUE)

SORTIE 

 [1] 2 1 5 5 1 1 5 5 2 2

Défi:

En essayant les fonctions ci-dessus, vous aurez réalisé que les échantillons sont effectivement aléatoires et qu’on n’obtient pas deux fois la même permutation . 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. Dessinez d’abord deux permutations aléatoires de « 1:10 » indépendamment et observez que vous obtenez résultats différents.

Définissez maintenant la graine avec, par exemple, set.seed(123) et répétez le tirage au sort . Observez que vous obtenez désormais les mêmes tirages au sort.

Répétez en définissant une graine différente.

Différentes permutations

R 

sample(1:10)

SORTIE 

 [1]  9  1  4  3  6  2  5  8 10  7

R 

sample(1:10)

SORTIE 

 [1]  4  9  7  6  1 10  8  3  2  5

Mêmes permutations avec la graine 123

R 

set.seed(123)
sample(1:10)

SORTIE 

 [1]  3 10  2  8  6  9  1  7  5  4

R 

set.seed(123)
sample(1:10)

SORTIE 

 [1]  3 10  2  8  6  9  1  7  5  4

Une graine différente

R 

set.seed(1)
sample(1:10)

SORTIE 

 [1]  9  4  7  1  2  5  3 10  6  8

R 

set.seed(1)
sample(1:10)

SORTIE 

 [1]  9  4  7  1  2  5  3 10  6  8

Extraire des échantillons à partir d’une distribution normale

La dernière fonction que nous allons voir est rnorm, qui tire un échantillon aléatoire à partir d’une distribution normale. Deux distributions normales de moyennes 0 et 100 et d’écarts types 1 et 5, notées N(0, 1) et N(100, 5), sont présentées ci-dessous.

Two normal distributions: *N(0, 1)* on the left and *N(100, 5)* on the right.
Two normal distributions: N(0, 1) on the left and N(100, 5) on the right.

Les trois arguments, n, mean et sd, définissent la taille de l’échantillon , et les paramètres de la distribution normale, c’est-à-dire la moyenne et son écart type. Les valeurs par défaut de ce dernier sont 0 et 1.

R 

rnorm(5)

SORTIE 

[1]  0.69641761  0.05351568 -1.31028350 -2.12306606 -0.20807859

R 

rnorm(5, 2, 2)

SORTIE 

[1]  1.3744268 -0.1164714  2.8344472  1.3690969  3.6510983

R 

rnorm(5, 100, 5)

SORTIE 

[1] 106.45636  96.87448  95.62427 100.71678 107.12595

Maintenant 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 à en apprendre davantage sur les trames de données.

Points clés

  • Comment interagir avec R