Comme tout bon langage de programmation (et logiciel plus largement), R
possède une fonction permettant d'accéder à sa documentation. Celle-ci vous paraîtra au mieux obscure lors de vos premières interactions avec R
, mais constitue une mine d'information incroyable (notamment pour identifier les arguments que peut prendre une fonction ou même simplement pour avoir des exemples d'utilisation de celles-ci). Gardez en tête, cependant, que la qualité de la documentation peut varier notamment lorsque vous consultez la documentation liée à une librairie dont le développement est récent.
Prenons par exemple la fonction grepl()
qui permet d'identifier la présence/l'absence d'une chaine de caractère dans un objet. Pour examiner sa documentation et accéder à des exemples sur comment l'utiliser, il vous suffit d'utiliser la fonction help()
(ou l'opérateur ?
qui renvoie exactement à la même chose).
# version longue
# forme: help(nom_de_la_fonction)
help(grepl)
# version courte
# forme: ?nom_de_la_fonction
?grepl
# pour les plus malpris(e)s
help(help)
?help
Évidemment, la documentation interne de R
possède des limites. Par exemple, son interface est peu agréable à l'oeil. Ensuite, et cette lacune est la plus importante, elle ne vous informe par sur quelle série de fonctions (ou librairies) sont adéquates pour effectuer une tâche donnée ou répondre à un problème. Ce faisant, votre meilleur support d'information reste l'exploration des forums spécialisés (comme Stackoverflow) à l'aide de votre moteur de recherche préféré.
Gardez en tête qu'un programmeur débutant, lors de la réalisation d'une tâche, peut facilement passer 80% de son temps dans le développement d'un projet à chercher sur ces forums. Pour un programmeur expérimenté, le ratio diminue à peine. Ainsi, n'hésitez pas à faire des recherches sur les forums en lien avec la tâche qui vous est assignée. Vous y trouverez des exemples de code utilisable, des explications sur pourquoi une telle approche est meilleure qu'une autre, et surtout, vous sauverez énormément de temps. En effet, la plus grande force de R
est sa large communauté et les milliers de pages de questions/réponses et de tutoriels qu'elle a produites.
mean
?mean
La fonction assign()
permet d'attribuer une valeur à une variable. Par exemple, il est possible d'assigner la valeur 5
à la variable x
permettant d'appeler x
au lieu de 5
. La fonction assign()
est rarement utilisée en soi, l'opérateur assignation <-
permettant d'effectuer la même opération de façon plus intuitive. Par exemple,
# e.g assignation de la valeur '5' à la variable 'x'
assign("x", 5)
x
## [1] 5
# L'utilisation de l'opérateur '<-' prend la forme suivante:
# objet_nommé <- valeur
# e.g assignation de la valeur '5' à la variable 'x'
x <- 5
x
## [1] 5
Évidement, l'assignation de valeurs à des variables prend son importance lorsque vous voulez conserver les résultats d'opération plus complexes ou pour permettre une meilleure lisibilité dans l'enchainement d'opérations avec plusieurs résultats intermédiaires. Par exemple, la chaine d'opération suivante:
# E.g. Calcul du temps total (en secondes) passé en cours lors d'un baccalauréat (sans laboratoire, 3 heures par semaines sur 15 semaines, 5 cours par session, 6 sessions sur 3 ans)
nb_de_seconde_par_cours <- 3*60*60 # 3h x 60 min x 60 secondes
nb_de_seance_par_cours_par_session <- 15
nb_de_cours_par_session <- 5
nb_de_sessions <- 6
nb_de_seconde_par_baccalaureat <- nb_de_seconde_par_cours * nb_de_seance_par_cours_par_session * nb_de_cours_par_session * nb_de_sessions
nb_de_seconde_par_baccalaureat
## [1] 4860000
Note: L'assignation d'une valeur à une variable n'implique pas que vous sauvegardez sur votre disque dur les résultats de vos opérations. Elles sont simplement sauvegardées dans la mémoire vive de votre ordinateur tant et aussi longtemps que votre session R est ouverte. RStudio vous offre la possibilité de sauvegarder votre session à la fermeture de
R
, mais cela n'est pas recommandé. Voir la section Lecture/écriture de données pour savoir comment sauvegarder vos résultats sur votre disque dur.
Assignez la valeur 5
à la variable premiere_variable
et la valeur 6
la la variable deuxieme_variable
puis assignez le résultat de leur multiplication à la variable resultat
. Imprimez ensuite le résultat.
premiere_variable <- 5
deuxieme_variable <- 6
resultat <- premiere_variable * deuxieme_variable
resultat
En R (et en programmation en général), la notion de type
est très importante. En effet, en indiquant le type d'une donnée particulière, vous indiquez à R
quelles opérations peuvent ou ne peuvent pas être appliquées sur celle-ci. Cela vous sera éventuellement très utile pour rédiger des tests permettant de vous assurer que votre code fait ce qu'il est censé faire, mais sera source de beaucoup de messages d'erreurs au début.
Voici une liste de types communs que vous rencontrerez dans R
:
Type | Exemple de valeurs | Exemples |
---|---|---|
integer (int) | Nombres entiers | 1, 2, 3, 4, ... |
numeric (num) | Nombres réels | 1.2, 1.4, 5.1, 7.9, ... |
logical (logi) | Valeurs booléennes | TRUE, FALSE, NA |
character (chr) | Texte | "R", "Statistique", "exemples", ... |
Pour examiner le type d'un objet, la fonction de base typeof()
est très utile (certaines fonctions comme str()
, examinée plus bas, mentionnent aussi les types en sus).
typeof(TRUE)
## [1] "logical"
typeof("TRUE")
## [1] "character"
Toute une série de fonctions vous permet de fixer/vérifier/tester le type d'un objet donné. Par exemple,
# pour les entiers
test <- as.integer(1)
typeof(test)
## [1] "integer"
is.integer(test)
## [1] TRUE
# pour les valeurs numériques
test <- as.numeric(1)
typeof(test)
## [1] "double"
is.numeric(test)
## [1] TRUE
# pour les valeurs logiques/booléennes
# à noter ici que toute valeur autre que 0 se verra transformée à TRUE par as.logical()
test <- as.logical(1)
typeof(test)
## [1] "logical"
is.logical(test)
## [1] TRUE
# pour les caractères
test <- as.character(1)
typeof(test)
## [1] "character"
is.character(test)
## [1] TRUE
À noter : Bien que le suivi des types vous apparaîtra peu utile pour ne pas dire inutile au début, celui-ci deviendra de plus en plus important à mesure que vos scripts se complexifieront, et surtout, à mesure que vous voudrez rédiger des scripts efficients (e.g. préallocations pour les boucles
for
).
Lorsque vous travaillez dans R
, vous n'effectuez pas des opérations sur des éléments libres (e.g. des entiers), mais plutôt sur des structures contenant ces éléments. Par exemple,
Structure | Description |
---|---|
vector | Structure à 1 dimension de longueur n d'éléments de même type |
matrix | Structure à 2 dimensions, m colonnes et n lignes, d'éléments de même type |
array | Sructure à x dimensions comprenant des éléments de même type |
list | Structure comprenant n éléments de même type ou de types différents (peut même contenir des structures de données comme des vecteurs, des matrices ou même des listes!) |
dataframe | Sera abordé dans le module sur le nettoyage des données |
Ainsi, pour prendre un exemple simple, lorsque vous effectuez une addition (e.g. entre 5 et 5), vous appliquez en fait une fonction prenant pour arguments des vecteurs unaires d'entiers.
# Démonstration
x <- as.integer(5)
is.vector(x)
help("+")
Les vecteurs étant les structures de données les plus souvent utilisées, il vaut la peine de s'y attarder plus longuement.
Ceux-ci peuvent apparaître sous plusieurs types suivant le type des éléments qu'ils contiennent. Ainsi, un vecteur numérique sera composé exclusivement d'éléments numériques, alors qu'un vecteur logique comprendra exclusivement des éléments booléens.
Deux fonctions sont particulièrement utiles pour travailler avec les vecteurs. La fonction c()
, qui vous permet de concaténer (joindre ensemble) des vecteurs unaires particuliers au sein d'un vecteur n-aire (ou même des vecteurs n-aires ensemble), et la fonction str()
qui vous permet d'examiner la structure des données d'un objet particulier (à distinguer de la fonction typeof()
qui ne donne pas d'information sur la structure des données, mais seulement sur le type).
vecteur_numerique <- c(3, 5, 10, 12.4, 87.9087)
str(vecteur_numerique)
## num [1:5] 3 5 10 12.4 87.9
vecteur_logique <- c(TRUE, FALSE, TRUE, TRUE)
str(vecteur_logique)
## logi [1:4] TRUE FALSE TRUE TRUE
vecteur_de_caracteres <- c("a", "chien", "abc", "TRUE")
str(vecteur_de_caracteres)
## chr [1:4] "a" "chien" "abc" "TRUE"
Pour voir les types possibles, consulter la documentation de la fonction vector()
(?vector()
).
Il est à noter que R
, lorsque le type des données n'est pas fixé manuellement, va tenter d'inférer le type de votre structure de données selon les éléments que vous incluez dans celle-ci. Par exemple,
# Démonstration
vecteur_inconnu_A <- c(TRUE, 1)
str(vecteur_inconnu_A)
## num [1:2] 1 1
vecteur_inconnu_B <- c("abc", TRUE, 1)
str(vecteur_inconnu_B)
## chr [1:3] "abc" "TRUE" "1"
Bien que cette liberté prise par R
puisse parfois être utile, elle peut aussi entrainer certaines frustrations en modifiant le type de vos données sans vous le dire.
5 + 5 # résultat attendu
## [1] 10
5 + "abc" # résultat attendu
## Error in 5 + "abc": non-numeric argument to binary operator
5 + TRUE # résultat surprenant puisque R a pris la liberté de modifier le type de TRUE de logique vers numérique
## [1] 6
x <- c(1, 2, 3)
y <- c(1, 2, "n.d.")
x[1] + x[2] # résultat attendu
## [1] 3
x[1] + y[2] # résultat surprenant puisque R, en voyant la valeur "n.d.", a attribué le type de vecteur de caractère à l'objet y
## Error in x[1] + y[2]: non-numeric argument to binary operator
Note: Garder en tête que
R
effectue l'inférence du type selon une échelle prédéfinie logique < numérique < caractère.
Pour accéder au contenu des vecteurs, deux approches peuvent être utilisées. D'une part, les éléments d'un vecteur étant indexés, vous pouvez récupérer l'élément d'intérêt par son index (toujours possible). D'autre part, pour les vecteurs nommés, vous pouvez récupérer l'élément d'intérêt par son nom (possible seulement lorsque des noms sont assignés aux différentes entrées).
# Par exemple, considérons le vecteur nommé suivant comprenant les heures travaillées par jour lors de la semaine dernière
heures_de_travail_par_jour <- c(3, 2.2, 2, 7, 4.3, 1, 13)
noms_jours_semaine <- c("Dimanche", "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi")
names(heures_de_travail_par_jour) <- noms_jours_semaine
# Pour additioner les heures réalisées du lundi au vendredi par index:
total_heure_travail_semaine_reguliere1 <-
sum(heures_de_travail_par_jour[2],
heures_de_travail_par_jour[3],
heures_de_travail_par_jour[4],
heures_de_travail_par_jour[5],
heures_de_travail_par_jour[6])
# OU
total_heure_travail_semaine_reguliere2 <-
sum(heures_de_travail_par_jour[c(2,3,4,5,6)])
# OU
total_heure_travail_semaine_reguliere3 <-
sum(heures_de_travail_par_jour[2:6])
# Vérification
total_heure_travail_semaine_reguliere1 ==
total_heure_travail_semaine_reguliere2
## [1] TRUE
total_heure_travail_semaine_reguliere2 ==
total_heure_travail_semaine_reguliere3
## [1] TRUE
# Pour additioner les heures réalisées durant la fin de semaine par noms:
total_heure_travail_fin_de_semaine <-
sum(heures_de_travail_par_jour["Samedi"],
heures_de_travail_par_jour["Dimanche"])
total_heure_travail_fin_de_semaine
## [1] 16
L'approche par index présente une grande flexibilité en plus de ne pas se limiter aux vecteurs nommés. Cependant, l'approche par nom offre une très grande précision dans la sélection de l'élément d'intérêt tout en offrant une meilleure lisibilité du code. Vous serez amené à utiliser les deux approches selon vos besoins.
Assignez un vecteur contenant les 6 premiers mois de l'année à la variable mois
. Puis, imprimez le mois de février en accédant à celui-ci à l'aide de son index.
mois <- c("Janvier", "Février", "Mars", "Avril", "Mai", "Juin")
mois[2]
vecteur <- c(1,2,3,4,5,6)
names(vecteur) <- c("Janvier", "Février", "Mars", "Avril", "Mai", "Juin")
vecteur["Mars"]