Cours
Programmation orientée objet avec S3 et R6 en R
4 h
23.6K
La programmation orientée objet (POO) est un paradigme de programmation où l’on conçoit les logiciels autour de données ou d’objets plutôt qu’autour de fonctions. Un « method » n’est rien d’autre qu’une fonction, dans le contexte de la POO. On parle d’orienté objet car tout le traitement s’articule autour des objets et de leurs champs. Chaque objet possède des attributs et des comportements.
En POO, on peut diviser l’ensemble du programme en différentes classes, ce qui facilite la compréhension de l’exécution. R est un langage de programmation fonctionnel, et la POO aide à gérer des problématiques de systèmes de grande taille. Elle est souvent utilisée pour les applications GUI, notamment les applications web. La POO est adaptée pour créer des outils d’analyse de données, mais moins pour l’analyse elle-même.
Systèmes de POO
On distingue principalement deux grands systèmes de POO, décrits ci‑dessous :
- Classes S3 : elles permettent la surcharge de fonctions.
- Classes S4 : elles contraignent plus strictement les données, ce qui facilite la fiabilité mais rend le débogage plus délicat.
Remarque : ces classes seront détaillées plus loin.
Objets dans R
Les objets sont des instances de classe. Par ailleurs, tout est objet dans R : pour en savoir plus, consultez Data types in R. Les objets peuvent aussi avoir des attributs comme class, attributes, dimnames, names, etc.
Par exemple, on assigne une valeur à des objets avec <- : ci‑dessous, « a1 » et « a2 » sont des variables auxquelles on assigne une valeur numérique.
a1 <- 10
a2 <- 20
On peut aussi assigner un ensemble de nombres : « a3 » est un objet contenant un vecteur de valeurs.
a3 <- c(10,20,30)
Ici, c place les nombres 10, 20 et 30 dans un vecteur.
Autre exemple concret : un élève, avec des attributs comme le nom, l’âge, la classe et le genre ; un professeur, avec le nom, l’âge et le genre.
st_name <- "andrew"
st_age <- 16
st_class <- 10
st_gender <- "male"
t_name <- "angelina"
t_age <- 26
t_gender <- "female"
student <- c(st_name, st_age, st_class, st_gender)
teacher <- c(t_name, t_age, t_gender)
print(student)
print(teacher)
[1] "andrew" "16" "10" "male"
[1] "angelina" "26" "female" Le code ci‑dessus produit la sortie suivante :
"andrew" "16" "10" "male"
"angelina" "26" "female"Dans cet exemple, on observe différents types d’objets. Les objets « student » et « teacher », aussi appelés variables, contiennent des valeurs de type « character » et « double ».
Maîtrisez vos compétences en matière de données avec DataCamp
Plus de 10 millions de personnes apprennent Python, R, SQL et d'autres compétences techniques grâce à nos cours pratiques élaborés par des experts du secteur.
Classe dans R
Une classe est un plan (blueprint) qui permet de créer un objet et regroupe ses variables membres ainsi que leurs attributs.
Comme vu précédemment, R propose deux systèmes de classes : S3 et S4.
Classe S3
Ces classes facilitent la surcharge des fonctions en les scindant en génériques et méthodes.
functions = generic + methods
S3 diffère fortement d’autres langages comme C# ou Java. Son implémentation est très simple : la distribution se fait uniquement sur le premier argument. Cela demande donc relativement peu de connaissances du point de vue du développeur.
S3 repose sur une convention de nommage stricte de type generic.pointclass.
generic.class
Les méthodes doivent accepter les mêmes arguments que le générique, et inclure un ...arg.
Construction et exemple de classe S3
L’exemple ci‑dessous montre comment construire une classe S3 : on crée une liste dont les composantes sont passées, on lui assigne un nom de classe, puis on affiche le résultat.
Ici, « studentBio » est une liste avec « student_name », « student_age » et « student_contact ». La classe est nommée « Student Info », et « studentBio » est l’objet nouvellement créé, affiché ensuite.
studentBio <- list(studentName = "Harry Potter", studentAge = 19, studentContact="London")
class(studentBio) <- "StudentInfo"
studentBio
$studentName
[1] "Harry Potter"
$studentAge
[1] 19
$studentContact
[1] "London"
attr(,"class")
[1] "StudentInfo"Le code ci‑dessus produit la sortie suivante :
$studentName
"Harry Potter"
$studentAge
19
$studentContact
"London"
attr(,"class")
"StudentInfo"Si vous n’êtes pas encore à l’aise avec l’écriture de fonctions en R, lisez A Tutorial on Using Functions in R.
Créer votre propre méthode générique en S3
Créez ci‑dessous votre fonction générique à l’aide du code suivant.
La fonction générique « contact » affecte l’objet passé en argument. « UseMethod » appelle la méthode appropriée du générique « contact » (le « dispatch »), c’est‑à‑dire la sélection de la méthode en fonction des arguments fournis.
contact <- function(object) {
UseMethod("contact")
}
Créons maintenant une méthode pour la classe « StudentInfo » définie plus haut. La méthode « contact », suivie en notation point du nom de classe « StudentInfo », accède à l’attribut « studentContact » via « $ ».
contact.StudentInfo <- function(object) {
cat("Your contact is", object$studentContact, "\n")
}
contact(studentBio)
Your contact is London
Le code utilise object$studentContact : l’objet est passé en argument à la fonction, et « $ » permet d’accéder à l’attribut « studentContact », d’où la sortie ci‑dessous.
Your contact is London
Classe S4
La classe S4 est plus stricte, plus conventionnelle et plus proche des concepts objets. Les classes y sont représentées par des définitions formelles. S4 propose des fonctions « setter » et « getter » pour les méthodes et génériques. Par rapport à S3, S4 prend en charge le multi‑dispatch.
Voyons ces classes R en les créant et en les illustrant par un exemple.
Une classe S4 se définit avec la fonction setClass.
setClass()Construction et exemple de classe S4
Comme indiqué, une classe S4 se définit avec setClass(). Nous allons utiliser setClass() pour créer et définir la classe S4, valider la cohérence des données (validation) et définir des valeurs par défaut (prototype).
Voici le code pour définir la classe et ses slots :
On définit une classe (et son « prototype ») où les slots sont précisés : nom de classe « employee », name de type character, id de type numeric, et contact de type character.
setClass("employee", slots=list(name="character", id="numeric", contact="character"))
Le code suivant permet de créer des instances (objets) de S4.
Créons un objet avec « new » de classe « employee », en renseignant les slots name, id et contact.
obj <- new("employee",name="Steven", id=1002, contact="West Avenue")
obj
An object of class "employee"
Slot "name":
[1] "Steven"
Slot "id":
[1] 1002
Slot "contact":
[1] "West Avenue"An object of class "employee"
Slot "name":
"Steven"
Slot "id":
1002
Slot "contact":
"West Avenue"On voit que l’objet créé est de classe « employee ». Le slot « name » vaut « Steven », le slot « id » vaut 1002 et le slot « contact » vaut « West Avenue ».
Fonctions et commandes
Pour vérifier si un objet est un objet S4, on peut utiliser les deux commandes suivantes :
La commande « is.object(obj) » vérifie si une variable ou instance référence un objet.
is.object(obj)
TRUE
Le code ci‑dessus produit la sortie suivante :
TRUELa commande « isS4(obj) » vérifie si une variable ou instance est un objet S4.
isS4(obj)
TRUE
Le code ci‑dessus produit la sortie suivante :
TRUEAccéder et modifier la valeur d’un slot
Accéder à un slot
On accède à un slot avec « @ » au lieu de « $ ».
« obj@name » permet d’accéder au nom « Steven », et de même pour « obj@id ».
obj@name
obj@id
'Steven'
1002
Le code ci‑dessus donne :
'Steven'
1002Modifier un slot
Modifions la valeur d’un slot avec l’opérateur d’affectation (« <- ») en assignant « North Avenue » à « obj@contact ».
obj@contact <- "North Avenue"
obj
An object of class "employee"
Slot "name":
[1] "Steven"
Slot "id":
[1] 1002
Slot "contact":
[1] "North Avenue"Le code ci‑dessus produit :
An object of class "employee"
Slot "name":
"Steven"
Slot "id":
1002
Slot "contact":
"North Avenue"On constate que le slot « contact » est passé de « West Avenue » à « North Avenue ».
On peut aussi utiliser « slot() » pour changer la valeur.
« slot(obj, "id") » cible le slot « id », auquel on assigne 1004, puis on affiche « obj ».
slot(obj,"id") <- 1004
obj
An object of class "employee"
Slot "name":
[1] "Steven"
Slot "id":
[1] 1004
Slot "contact":
[1] "North Avenue"An object of class "employee"
Slot "name":
"Steven"
Slot "id":
1004
Slot "contact":
"North Avenue"Ici, le slot « id » a été modifié de 1002 à 1004.
Créer votre propre méthode générique en S4
Créons une fonction d’affichage adaptée à nos besoins avec « setMethod() » et le générique « show() ». On accède aux valeurs des slots avec « @ » et on affiche leurs noms. Enfin, on obtient le résultat en évaluant « obj ».
setMethod("show",
"employee",
function(object) {
cat("Name:",object@name, "\n")
cat("Id:",object@id, "\n")
cat("Contact:", object@contact, "\n")
}
)
obj
Name: Steven
Id: 1004
Contact: North AvenueName: Steven
Id: 1004
Contact: North AvenueLa sortie affiche les noms des slots accompagnés de leurs valeurs respectives.
Félicitations
Félicitations, vous êtes arrivé au bout de ce tutoriel !
Dans ce tutoriel, vous avez découvert la programmation orientée objet (POO), les objets de R, les classes S3 et S4, leur construction, la création de fonctions génériques avec des exemples, et bien plus encore.
Pour aller plus loin avec R, découvrez les cours DataCamp :
Sujets