Base 1: Objets, opérateurs et mathématiques

N’oubliez pas de nettoyer votre “Global Environnment” avec la fonction rm(list=ls()), pour éviter d’être encombré de variable. N’hésitez surtout pas à les supprimer si ce sont des exemples donnés dans des tutos, vous pouvez les recréer facilement. R-Studio n’est pas une cave, un peu d’ordre, ça aide en statistique. Nous vous recommandons de tester vous-même les codes en les recopiant dans la console, mais vous pouvez simplement les lancer depuis la fenêtre de script.

Type de données/objets

Dans R vous pouvez inscrire des nombres par exemple:

2

## [1] 2

34

## [1] 34

920

## [1] 920

10000000000000 

## [1] 1e+13

Vous pouvez également écrire des commentaires en utilisant le signe # devant les mots/phrases:

# Ceci est un commentaire

On utilise ça dans les scripts pour expliquer les lignes de codes, mais pas vraiment dans des lignes de commande dans la console. Vous pouvez aussi créer des mots ou chaînes de caractères en les inscrivant entre guillemets:

"chocolat"

## [1] "chocolat"

"pizza"

## [1] "pizza"

"Purée de pomme de terre" 

## [1] "Purée de pomme de terre"

Comme vous pouvez le voir, il est possible d’avoir des accents, des majuscules ou des espaces (caractères spéciaux). Généralement, on évitera un maximum d’utiliser des caractères spéciaux. Remarquez les différences de coloration du code.

Les variables

Naturellement, R est un semi-langage de programmation, il peut donc gérer des variables. Pour stocker une valeur dans une variable, il suffit d’indiquer le nom de la variable ainsi que la valeur que l’on souhaite lui attribuer et de mettre entre les deux (=) (<-) ou (->):

a<-12 
b="magicien"
32+19-> c 

Lorsque l’on utilise la flèche, il faut veiller à ce qu’elle soit dirigée de la valeur vers la variable. Pour afficher la valeur contenue dans une variable, il suffit d’inscrire le nom de la variable:

a

## [1] 12

b 

## [1] "magicien"

c 

## [1] 51

On peut également faire des calcules avec les variables ou toute autre sorte de manipulation :

a-c 

## [1] -39

d=c/a 

Remarque: pour utiliser plusieurs commandes sur la même ligne, il suffit d’utiliser le signe (;):

a

## [1] 12

b

## [1] "magicien"

c

## [1] 51

d

## [1] 4.25

Naturellement, il n’est pas possible de faire des calcules avec les chaînes de caractères :

# b+c

Ces variables sont des objets et apparaissent dans le cadran en haut à droite de Rstudio (référence au tuto 1), vous pouvez en voir le contenu. Lorsqu’on attribue une nouvelle valeur à une variable, la précédente valeur est effacée. C’est pour cette raison qu’il faut faire attention à la gestion des variables.

a

## [1] 12

a = 52344
a

## [1] 52344

Les vecteurs

Le prochain type d’objet abordé est le vecteur. Le vecteur est une série de valeur contenue dans le même objet. Pour le créer il faut utiliser la fonction de concaténation abrégée c() en séparant chaque valeur par une virgule dans R:

v0<-c(1,2,3,4,5)
v1<-c(3,54,1,8,10)
v2<-c("lait","manioc","sésame")
v3<-c("ananas",72,1,"nairobi",3)
v0;v1;v2;v3

## [1] 1 2 3 4 5

## [1]  3 54  1  8 10

## [1] "lait"   "manioc" "sésame"

## [1] "ananas"  "72"      "1"       "nairobi" "3"

Ainsi, nous avons créé des vecteurs numériques (v1) et à chaîne de caractères (v2 et v3). En effet, l’objet devient automatiquement une chaîne de caractères si au moins l’un de ses éléments est un caractère. Pour tester cela, nous pouvons utiliser la fonction class():

class(v0)

## [1] "numeric"

class(v1)

## [1] "numeric"

class(v2)

## [1] "character"

class(v3)

## [1] "character"

Ici, “numeric” signifie que c’est un objet numérique et “character” une chaîne de caractère…(Et là, vous dites: “merci Einstein!”, même s’il n’était pas traducteur). Vous pouvez tester cette fonction sur les autres objets créés (a,b,c et d).

class(a)

## [1] "numeric"

class(b)

## [1] "character"

Comme pour les variables classiques, vous pouvez faire diverses manipulations:

v1*3

## [1]   9 162   3  24  30

v0-5

## [1] -4 -3 -2 -1  0

Pour les calculs entre vecteurs, il y a une règle supplémentaire: la longueur. Créons un vecteur de longueur 2 et un autre de longueur 4 :

v4<-c(1,0)
v5<-c(1,1,1,1)

Lorsque les deux vecteurs ont des diviseurs communs (ici 2 pour v4 avec v0 ou v1), les calcules fonctionnent:

v4+v0

## Warning in v4 + v0: la taille d'un objet plus long n'est pas multiple de la
## taille d'un objet plus court

## [1] 2 2 4 4 6

v4*v0

## Warning in v4 * v0: la taille d'un objet plus long n'est pas multiple de la
## taille d'un objet plus court

## [1] 1 0 3 0 5

v4-v1

## Warning in v4 - v1: la taille d'un objet plus long n'est pas multiple de la
## taille d'un objet plus court

## [1]  -2 -54   0  -8  -9

v4/v1

## Warning in v4/v1: la taille d'un objet plus long n'est pas multiple de la taille
## d'un objet plus court

## [1] 0.3333333 0.0000000 1.0000000 0.0000000 0.1000000

Mais ça ne fonctionne pas lorsqu’il n’y a pas de diviseur commun:

v5+v0

## Warning in v5 + v0: la taille d'un objet plus long n'est pas multiple de la
## taille d'un objet plus court

## [1] 2 3 4 5 6

v5-v1

## Warning in v5 - v1: la taille d'un objet plus long n'est pas multiple de la
## taille d'un objet plus court

## [1]  -2 -53   0  -7  -9

Pour contrôler la longueur d’un vecteur, il y a deux moyens: le plus simple, c’est de regarder la fenêtre en haut à droite les informations de la variable. Ou d’utiliser la fonction lenght():

length(v5)

## [1] 4

length(v0)

## [1] 5

length(v4)

## [1] 2

Il existe plusieurs autres fonctions pour les vecteurs: Longueur length(), Somme sum(), Minimum min(), Maximum max(), Portée range(), Moyenne mean(), Médiane median(), Écart type sd(), Variance var(), Résume summary().

sum(v4)

## [1] 1

min(v0)

## [1] 1

max(v1)

## [1] 54

median(v5)

## [1] 1

sd(0)

## [1] NA

var(1)

## [1] NA

sum(5)

## [1] 5

Gestion des objets

Pour gérer les objets vous pouvez utiliser ces 2 fonctions importantes: ls() et remove() ou rm() en abrégé. ls(), affichent tous les objets créés (laisser tel quel). remove() ou rm() supprime les objets sélectionnés. Exemple (Attention avant de lancer l’exemple assurer vous d’avoir enregistré tous les objets importants, puisque la dernière fonction les supprime tous):

# Faire disparaitre le vecteur v0
rm(v0) 
# Supprime tous les objets créés
remove(list=ls())
# ou rm(list=ls())

Vecteurs(suite)

Maintenant tous les objets de votre environnement sont effacés, lorsque nous ferons des exemples plus tard, nous créerons les variables justes avant pour vous permettre d’utiliser les exemples indépendamment des autres tutos, c’est-à-dire sans avoir besoin de refaire tout le tuto depuis le début. Il existe d’autres moyens de créer des vecteurs. Nous pouvons par exemple les nommer directement:

v0<-c(point=1, lunette=6, tableau=19)

Ou le faire après coup (le vecteur des noms doit avoir la même taille) :

v0<-c(27,1,9)
names(v0)<-c("métal","soleil","chou")

Si vous souhaitez générer une série de nombre par pas de 1 vous pouvez utiliser le signe (:) entre les deux nombres servant de borne:

v0<-1:10
v1<-5:-2
v2<-c(4:1,5,1,6)
v3<-c(v0,v1)
v4<-c(3,v2,-2:5,0)
v0;v1;v2;v3;v4

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

## [1]  5  4  3  2  1  0 -1 -2

## [1] 4 3 2 1 5 1 6

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

##  [1]  3  4  3  2  1  5  1  6 -2 -1  0  1  2  3  4  5  0

Remarquez que nous pouvons le faire dans les deux sens (ascendant/descendant). Pour réaliser des séries plus personnalisées vous pouvez utiliser la fonction seq() en indiquant dans un premier temps le nombre de départ, puis le nombre d’arrivée, finalement indiquez la taille du saut après avoir écrit “by=”:

seq(3,11,by=4)

## [1]  3  7 11

seq(23,9,by=-5)

## [1] 23 18 13

v0<-seq(8,13,by=0.5)
v0

##  [1]  8.0  8.5  9.0  9.5 10.0 10.5 11.0 11.5 12.0 12.5 13.0

Remarques: Premièrement, si les sauts que vous souhaitez faire ne correspondent pas exactement à l’écart entre les deux nombres, R va arrêter le compte juste avant de dépasser la valeur limite. Deuxièmement, si vous souhaitez faire une série descendante, il faut indiquer un nombre négatif. Finalement, la fonction utilisée ici est un abrégé, si nous voulions faire du zèle, nous devrions utiliser la fonction complète:

seq(from=1,to=10,by=1)

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

Nous expliquerons dans un autre tuto pourquoi il existe plusieurs versions et dans quel cas il est possible d’utiliser la version raccourcie. Dans ce qui suit, nous n’imputerons pas forcément les valeurs à des variables pour les exemples, mais sachez que c’est possible de le faire pour tous les cas qui vont suivre. Nous pouvons également répéter un nombre ou une série de nombres pour créer nos vecteurs:

v0<-0:1
rep(5, time=10)

##  [1] 5 5 5 5 5 5 5 5 5 5

rep(c(3,2,1), time=3)

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

rep(4:1,time=2)

## [1] 4 3 2 1 4 3 2 1

rep(v0, time=5)

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

Mais il est également possible de répéter plusieurs fois chaque élément d’un vecteur pour l’agrandir:

v0<-0:1
rep(c(1,2,3), each=2)

## [1] 1 1 2 2 3 3

rep(v0, each=5)

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

Sélection Il est possible de manipuler qu’une partie des vecteurs:

v0<-1:10
v1<-c(1:4,5,1,3,6,8,1)
v0[1]

## [1] 1

v0[7]

## [1] 7

v0[2:5]

## [1] 2 3 4 5

v0[c(1,3,8)]

## [1] 1 3 8

v0[2]+v1[3]

## [1] 5

v0[3:9]*v1[1:7]

## [1]  3  8 15 24 35  8 27

Gardez en mémoire le fait que cela sera très utile pour la manipulation de matrices et de structures de données, mais qu’il existe un package qui gère mieux ce genre de situation (dyplr de tidyverse)

Opérateurs Avant d’entamer les opérateurs, nous allons commencer par un petit exemple. Nous allons voir ce qu’il se passe lorsque nous utilisons les signes < et >:

2>3

## [1] FALSE

1<100

## [1] TRUE

Suivant le code inscrit, R nous renvoie soit TRUE (vrai) soit FALSE (Faux). En guise d’explication simple, il nous indique si l’expression ou la condition que nous lui avons proposée est vraie ou fausse. Dans notre exemple 2 n’est pas plus grand que 3 (donc faux) et 1 est bien inférieurs à 100 (donc vrai). Cela marche aussi pour les vecteurs:

v0<-1:10
v0

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

v0>5

##  [1] FALSE FALSE FALSE FALSE FALSE  TRUE  TRUE  TRUE  TRUE  TRUE

Remarque: Jusqu’au cinquième nombre qui correspond à 5 toutes les valeurs renvoyées par l’expression précédente sont “FALSE”, même le 5, puisque nous avons demandé à R si le nombre est “strictement égal à 5” or les nombres allant de 1 à 5 sont inférieurs ou égaux à 5 (ici le 5). Il existe plusieurs autres opérateurs:

Arithmétique

Remarque: le modulo est le reste d’une division

Relationnel

Logique

Remarque: Les signes “|” (ou par élément) et “||” (ou simple) n’apparaissent pas dans le tableau à cause de leur particularité, mais ce sont bien ces signes.

Pour la dernière série d’opérateurs, voici quelques exemples d’utilisation:

# Division Euclidienne avec résultat et reste:
10%/%6 ; 10%%6

## [1] 1

## [1] 4

# Est-ce que 10 et 5 sont tous les deux supérieurs à 3 ?
10&5>3

## [1] TRUE

# Est-ce que 10 et 1 sont tous les deux supérieurs à 3 ?
10&1>3

## [1] FALSE

# Est-ce que 10 ou 1 est supérieur à 3 ?
10|1>3 

## [1] TRUE

Ce tuto est terminé!

Gardez en mémoire le fait que cela sera très utile pour la manipulation de matrices et de structures de données, mais qu’il existe un package qui gère mieux ce genre de situation (dyplr de tidyverse)

2>3

## [1] FALSE

1<100

## [1] TRUE

v0 <- 1:10
v0

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

v0>5

##  [1] FALSE FALSE FALSE FALSE FALSE  TRUE  TRUE  TRUE  TRUE  TRUE

TRUE

## [1] TRUE

FALSE

## [1] FALSE

# Fonction pour transformer un élément en nombre
as.numeric(TRUE)

## [1] 1

# Fonction pour transformer un élément en nombre
as.numeric(FALSE)

## [1] 0

TRUE + TRUE

## [1] 2

FALSE - 10

## [1] -10

v2 <- c(1,2)
v2

## [1] 1 2

v2[c(TRUE,FALSE)]

## [1] 1

v2[c(FALSE,TRUE)]

## [1] 2

v2[c(FALSE,FALSE)]

## numeric(0)

v2[c(TRUE,TRUE)]

## [1] 1 2

# Division Euclidienne avec résultat et reste:
10%/%6 ; 10%%6

## [1] 1

## [1] 4

# Est-ce que 10 et 5 sont tous les deux supérieurs à 3 ?
10&5>3

## [1] TRUE

# Est-ce que 10 et 1 sont tous les deux supérieurs à 3 ?
10&1>3

## [1] FALSE

# Est-ce que 10 ou 1 est supérieur à 3 ?
10|1>3 

## [1] TRUE

v3 <- 1:10
v3

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

v4 <- c("a","b","c","d","e","f","g","h","i","j")
v4

##  [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j"

# Renvoie des booléens (TRUE si la condition logique est respecté FALSE sinon)
v3>=5

##  [1] FALSE FALSE FALSE FALSE  TRUE  TRUE  TRUE  TRUE  TRUE  TRUE

# Ces booléens peuvent être utilisés pour faire des sélections
v3[v3>=5]

## [1]  5  6  7  8  9 10

# Même dans une autre liste de même taille
v4[v3>=5]

## [1] "e" "f" "g" "h" "i" "j"

# Avec des commandes plus complexes
v4[v3>=5 | v4=="b"]

## [1] "b" "e" "f" "g" "h" "i" "j"

v4 <- 1:4
v3

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

v4

## [1] 1 2 3 4

5 %in% v3

## [1] TRUE

5 %in% v4

## [1] FALSE

# On peut même le faire entre les différents éléments de deux vecteurs
v3 %in% v4

##  [1]  TRUE  TRUE  TRUE  TRUE FALSE FALSE FALSE FALSE FALSE FALSE

v3

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

v3==10

##  [1] FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE  TRUE

ifelse(v3==10, "vrai", "faux")

##  [1] "faux" "faux" "faux" "faux" "faux" "faux" "faux" "faux" "faux" "vrai"

ifelse(v3==10, "égal à 10", "pas égal à 10")

##  [1] "pas égal à 10" "pas égal à 10" "pas égal à 10" "pas égal à 10"
##  [5] "pas égal à 10" "pas égal à 10" "pas égal à 10" "pas égal à 10"
##  [9] "pas égal à 10" "égal à 10"

ifelse(v3==10, v3*10, v3)

##  [1]   1   2   3   4   5   6   7   8   9 100

ifelse(v3<10, v3*10, v3/2)

##  [1] 10 20 30 40 50 60 70 80 90  5

l1 <- list(1,4,"carotte",TRUE)
l2 <- list(v1, v0, "Ceci est une phrase", l1)
l1

## [[1]]
## [1] 1
## 
## [[2]]
## [1] 4
## 
## [[3]]
## [1] "carotte"
## 
## [[4]]
## [1] TRUE

l2

## [[1]]
##  [1] 1 2 3 4 5 1 3 6 8 1
## 
## [[2]]
##  [1]  1  2  3  4  5  6  7  8  9 10
## 
## [[3]]
## [1] "Ceci est une phrase"
## 
## [[4]]
## [[4]][[1]]
## [1] 1
## 
## [[4]][[2]]
## [1] 4
## 
## [[4]][[3]]
## [1] "carotte"
## 
## [[4]][[4]]
## [1] TRUE

# ça ne suffit pas pour manipuler l'élément séléctionné
l1[1]

## [[1]]
## [1] 1

l1[[1]]

## [1] 1

class(l1)

## [1] "list"

class(l1[1])

## [1] "list"

class(l1[[1]])

## [1] "numeric"

l3 <- list(vecteur0 = v0, vecteur1 = v1)
l3$vecteur0

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

l3$vecteur1

##  [1] 1 2 3 4 5 1 3 6 8 1

l0 <- list(vecteur1 = v1, animal = "oiseau")
l4 <- list(liste0 = l0, vecteur = v0)
l4

## $liste0
## $liste0$vecteur1
##  [1] 1 2 3 4 5 1 3 6 8 1
## 
## $liste0$animal
## [1] "oiseau"
## 
## 
## $vecteur
##  [1]  1  2  3  4  5  6  7  8  9 10

l4[[1]]

## $vecteur1
##  [1] 1 2 3 4 5 1 3 6 8 1
## 
## $animal
## [1] "oiseau"

l4[[1]][[2]]

## [1] "oiseau"

l4$liste0

## $vecteur1
##  [1] 1 2 3 4 5 1 3 6 8 1
## 
## $animal
## [1] "oiseau"

l4$liste0$animal

## [1] "oiseau"

l4$liste0[[2]]

## [1] "oiseau"

l4[[1]]$animal

## [1] "oiseau"