Commencer avec R

Comme détaillé dans l'introduction, R est un langage de programmation open source extrêmement polyvalent pour la statistique et la science des données. Il est largement utilisé dans tous les domaines où il existe des données - entreprises, industrie, gouvernement, médecine, universités, etc.
Dans ce chapitre, vous allez découvrir R-comment l'invoquer, ce qu'il peut faire et quels fichiers il utilise. Nous couvrirons juste assez pour vous donner les bases dont vous avez besoin pour travailler à travers les exemples dans les prochains chapitres, où les détails seront présentés.
R peut déjà être installé sur votre système, si votre employeur ou université l'a mis à la disposition des utilisateurs. Sinon, voir l'annexe A.
pour les instructions d'installation.

Détails
Catégorie parente: Logiciel R
Catégorie : Commencer avec R

R est typique dans les langages de programmation fonctionnels, un thème commun dans la programmation R est l'évitement de l'itération explicite. Au lieu de coder des boucles, vous exploitez les fonctionnalités de R, qui vous permettent d'exprimer implicitement un comportement itératif. Cela peut conduire à un code qui s'exécute beaucoup plus efficacement, et il peut faire une énorme différence de temps lors de l'exécution de R sur de grands ensembles de données.
Comme vous le verrez, la nature de la programmation fonctionnelle du langage R offre de nombreux avantages:
• Code plus clair et plus compact
• Vitesse d'exécution potentiellement beaucoup plus rapide
• Moins de débogage, car le code est plus simple
• Transition plus facile vers la programmation parallèle
Pour qui ce tutoriel est-il?
Beaucoup utilisent R principalement de manière ad hoc - pour tracer un histogramme ici, y effectuer une analyse de régression et effectuer d'autres tâches discrètes impliquant des opérations statistiques. Mais ce cours s'adresse à ceux qui souhaitent développer des logiciels en R. Les compétences en programmation de nos lecteurs potentiels peuvent aller de n'importe où d'un développeur professionnel à «j'ai suivi un cours de programmation au collège», mais leur objectif principal est d'écrire R code à des fins spécifiques. (Les connaissances statistiques ne seront généralement pas nécessaires.)
Voici quelques exemples de personnes susceptibles de bénéficier de ce tutoriel:
• Analystes employés, par exemple, par un hôpital ou une agence gouvernementale qui produisent régulièrement des rapports statistiques et qui ont besoin de développer des programmes de production à cette fin.
• Les chercheurs universitaires élaborent une méthodologie statistique qui est soit nouvelle soit qui combine des méthodes existantes dans des procédures intégrées qui doivent codifier cette méthodologie afin qu'elle puisse être utilisée par la communauté générale de la recherche.
• Les spécialistes du marketing, du soutien aux litiges, du journalisme, de l'édition, etc., qui ont besoin de développer du code pour produire des présentations graphiques sophistiquées de données.
• Les programmeurs professionnels ayant une expérience dans le développement de logiciels qui ont été assignés par leurs employeurs à des projets impliquant une analyse statistique
• Les étudiants en cours de calcul statistique

En conséquence, ce tutoriel n'est pas un recueil de la myriade de types de méthodes statistiques disponibles dans le merveilleux paquet R. Il s'agit vraiment de programmation et couvre des sujets liés à la programmation qui manquent dans la plupart des autres livres sur R. Je place une programmation sur même les sujets de base. Voici quelques exemples de cette approche en action:
• Tout au long du livre, vous trouverez des sections "Exemple étendu". Celles-ci présentent généralement des fonctions complètes, à usage général, plutôt que des fragments de code iso¬lés basés sur des données spécifiques. En effet, vous pouvez trouver certaines de ces fonctions utiles pour votre propre travail quotidien. En étudiant ces exemples, vous apprenez non seulement comment fonctionnent les constructions R individuelles, mais aussi comment les assembler en un programme utile. Dans de nombreux cas, j'ai
a inclus une discussion sur les alternatives de conception, répondant à la question "Pourquoi l'avons-nous fait de cette façon?"
• Le matériel est abordé en tenant compte des sensibilités du programmeur. Par exemple, dans la discussion sur les trames de données, j'affirme non seulement qu'une trame de données est une liste R, mais que je souligne également les implications de ce fait sur la programmation. Des comparaisons de R à d'autres langues sont également introduites lorsqu'elles sont utiles, pour ceux qui connaissent d'autres langues.
• Le débogage joue un rôle clé lors de la programmation dans n'importe quelle langue, mais il n'est pas souligné dans la plupart des livres R. Dans ce livre, je consacre un chapitre entier aux techniques de débogage, en utilisant l'approche de «l'exemple étendu» pour présenter des démonstrations élaborées de la façon dont les programmes réels sont débogués.
• Aujourd'hui, les ordinateurs multicœurs sont courants même à la maison, et la programmation des unités de traitement graphique (GPU) effectue une révolution tranquille dans le calcul scientifique. Un nombre croissant d'applications R implique de très grandes quantités de calculs, et le traitement en parallèle est devenu un problème majeur pour les programmeurs en R. Ainsi, il y a un chapitre sur ce sujet, qui présente à nouveau non seulement la mécanique mais aussi des exemples étendus.
• Il y a un chapitre séparé sur la façon de tirer profit de la connaissance du comportement interne de R et d'autres facilités pour accélérer le code R.
• Un chapitre discute de l'interface de R avec d'autres langages, tels que C et Python, en insistant sur les exemples étendus ainsi que des conseils sur le débogage.

Détails
Catégorie parente: Logiciel R
Catégorie : Commencer avec R

Les avantages de l'orientation de l'objet peuvent être expliqués par l'exemple. Consider la régression statistique. Lorsque vous effectuez une analyse de régression avec d'autres progiciels statistiques, tels que SAS ou SPSS, vous obtenez une montagne de résultats à l'écran. En revanche, si vous appelez la fonction de régression lm () dans R, la fonction renvoie un objet contenant tous les résultats: les coefficients estimés, leurs erreurs standard, les résidus, etc. Vous choisissez ensuite, par programme, les parties de cet objet à extraire.
Vous verrez que l'approche de R rend la programmation beaucoup plus facile, en partie parce qu'elle offre une certaine uniformité d'accès aux données. Cette uniformité découle du fait que R est polymorphe, ce qui signifie qu'une seule fonction peut être appliquée à différents types d'entrées, que la fonction traite de manière appropriée. Une telle fonction est appelée une fonction générique. (Si vous êtes un programmeur C ++, vous avez vu un concept similaire dans les fonctions virtuelles.)
Par exemple, considérez la fonction plot (). Si vous l'appliquez à une liste de nombres, vous obtenez une intrigue simple. Mais si vous l'appliquez à la sortie d'une analyse de régression, vous obtenez un ensemble de graphiques représentant différents aspects de l'analyse. En effet, vous pouvez utiliser la fonction plot () sur n'importe quel objet produit par R. C'est sympa, car cela signifie que vous, en tant qu'utilisateur, avez moins de commandes à retenir!

Détails
Catégorie parente: Logiciel R
Catégorie : Commencer avec R

 

Pour notre prochain exemple, nous allons passer en revue une brève analyse de régression statistique. Il n'y a pas beaucoup de programmation réelle dans cet exemple, mais elle illustre comment certains des types de données que nous venons de décrire sont utilisés, y compris les objets S3 de R. En outre, il servira de base à plusieurs de nos exemples de programmation dans les chapitres suivants.
J'ai un fichier, ExamsQuiz.txt, contenant des notes d'une classe que j'ai enseigné. Voici ses premières lignes:

  1. 2 3. 3 4
  2. m .3 2 3 .7
  3. 4 4 3 4
  4. 2 .3 0 3 3
Source code

Les chiffres correspondent aux notes sur une échelle de quatre points; 3.3 est un B +, par exemple. Chaque ligne contient les données pour un étudiant, comprenant la note de l'examen à mi-parcours, la note de l'examen final et la note moyenne du questionnaire. Il pourrait être intéressant de voir à quel point les notes de mi-session et de quiz prédisent la note de l'étudiant à l'examen final.
Commençons par lire dans le fichier de données:

  1. > examsquiz <- read.table("ExamsQuiz.txt",header=FALSE)
Source code

Notre fichier n'inclut pas une ligne d'en-tête nommant les variables dans chaque enregistrement d'étudiant, nous avons donc spécifié header = FALSE dans l'appel de la fonction. Ceci est un exemple d'un argument par défaut, dont nous avons parlé plus tôt. En fait, la valeur par défaut de l'argument d'en-tête est déjà FALSE (que vous pouvez vérifier en consultant l'aide en ligne de R pour read.table ()), donc nous n'avons pas besoin de spécifier ce paramètre, mais c'est plus clair.
Nos données sont maintenant dans examsquiz, qui est un objet R de classe data.frame.
  1. > class(examsquiz)
  2. [1] "data.frame"
Source code

Juste pour vérifier que le fichier a été correctement lu, jetons un coup d'œil aux premières lignes:
  1. > head(examsquiz)
  2. V1 V2 V3
  3. 1 2.0 3.3 4.0
  4. 2 3.3 2.0 3.7
  5. 3 4.0 4.3 4.0
  6. 4 2.3 0.0 3.3
  7. 5 2.3 1.0 3.3
  8. 6 3.3 3.7 4.0
Source code

En l'absence d'un en-tête pour les données, R a nommé les colonnes V1, V2 et V3. Les numéros de ligne apparaissent sur la gauche. Comme vous pourriez le penser, il serait préférable d'avoir un en-tête dans notre fichier de données, avec des noms significatifs comme Exam1. Dans les exemples suivants, nous spécifierons généralement les noms.
Essayons de prédire le score de l'examen 2 (donné dans la deuxième colonne de examsquiz) de l'examen 1 (première colonne):
  1. lma <- lm (examsquiz [, 2] ~ examsquiz [, 1])
Source code

L'appel de la fonction lm () (pour le modèle linéaire) ordonne à R d'ajuster cette équation de prédiction:
Examen prédit 2 = fio + examen 1
Ici, et sont des constantes à estimer à partir de nos données. En d'autres termes, nous alignons une ligne droite sur les paires (examen 1, examen 2) de nos données. Ceci est fait par une méthode classique des moindres carrés. (Ne vous inquiétez pas si vous n'avez pas de contexte dans ce domaine.)
Notez que les notes de l'examen 1, qui sont stockées dans la première colonne de notre cadre de données, sont collectivement appelées examsquiz [, 1]. L'omission du premier indice (le numéro de ligne) signifie que nous faisons référence à une colonne entière de la trame. Les scores de l'examen 2 sont référencés de la même manière. Ainsi, notre appel à lm () ci-dessus prédit la deuxième colonne de examsquiz à partir du premier.
Nous aurions aussi pu écrire

  1. lma <- lm (examsquiz $ V2 ~ examsquiz $ V1)
Source code

rappelant qu'une trame de données est juste une liste dont les éléments sont des vecteurs. Ici, les colonnes sont les composants V1, V2 et V3 de la liste.
Les résultats renvoyés par lm () sont maintenant dans un objet que nous avons stocké dans la variable lma. C'est une instance de la classe LM. Nous pouvons lister ses composants en appelant attributs ():
  1. > attributes(lma)
  2. $names
  3. [1] "coefficients" "residuals" "effects" "rank"
  4. [5] "fitted.values" "assign" "qr" "df.residual"
  5. [9] "xlevels" "call" "terms" "model"
  6. $class
  7. [1] "lm"
Source code

Comme d'habitude, une comptabilité plus détaillée peut être obtenue via l'appel str (lma). Les valeurs estimées de pi sont stockées dans les coefficients lma $. Vous pouvez les afficher en tapant le nom à l'invite.
Vous pouvez également sauvegarder certaines données en abrégeant les noms de composants, tant que vous ne raccourcissez pas le nom d'un composant au point d'être ambigu. Par exemple, si une liste comprend les composants xyz, xywa et xbcde, les deuxième et troisième composants peuvent être abrégés en xyw et xb, respectivement. Donc, ici, nous pourrions taper ce qui suit:
  1. > lma $ coef
  2. (Intercept) examsquiz [, 1] 1.1205209 0.5899803
Source code

Puisque lma $ coefficients est un vecteur, l'imprimer est simple. Mais considérez ce qui se passe lorsque vous imprimez l'objet lui-même:
> lma Appelez:
lm (formule = examsquiz [, 2] ~ examsquiz [, 1])
Coefficients
(Intercept) examsquiz [, 1]
1,121 0,590
Pourquoi R n'a-t-il imprimé que ces éléments et non les autres composants de lma? La réponse est qu'ici, R utilise la fonction print (), qui est un autre exemple de fonctions génériques. En tant que fonction générique, print () transmet le travail à une autre fonction dont le travail consiste à imprimer des objets de la classe lm - la fonction print.lm () - et c'est ce que cette fonction affiche.
Nous pouvons obtenir une impression plus détaillée du contenu de lma en appelant summary (), la fonction générique discutée plus haut. Il déclenche un appel à summary.lm () dans les coulisses, et nous obtenons un résumé spécifique à la régression:

  1. > summary(lma)
  2. Call:
  3. lm(formula = examsquiz[, 2] ~ examsquiz[, 1])
  4. Residuals:
  5. Min 1Q Median 3Q Max
  6. -3.4804 -0.1239 0.3426 0.7261 1.2225
  7. Coefficients:
  8. Estimate Std. Error t value Pr(>|t|)
  9. (Intercept) 1.1205 0.6375 1.758 0.08709 .
  10. examsquiz[, 1] 0.5900 0.2030 2.907 0.00614 **
  11. ...
Source code

Un certain nombre d'autres fonctions génériques sont définies pour cette classe. Consultez l'aide en ligne de lm () pour plus de détails. (L'utilisation de la documentation en ligne de R est abordée à la section 1.7.)
Pour estimer une équation de prédiction pour l'examen 2 à partir de l'examen 1 et des scores du quiz, nous utiliserons la notation +:
  1. > lmb <- lm(examsquiz[,2] ~ examsquiz[,1] + examsquiz[,3])
Source code

Notez que le + ne signifie pas que nous calculons la somme des deux quantités. C'est simplement un délimiteur dans notre liste de variables prédictives.

 

Détails
Catégorie parente: Logiciel R
Catégorie : Commencer avec R

 

R a une variété de structures de données. Ici, nous allons esquisser quelques-unes des structures les plus fréquemment utilisées pour vous donner un aperçu de R avant de plonger dans les détails. De cette façon, vous pouvez au moins commencer avec des exemples significatifs, même si l'histoire derrière eux doit attendre.


1 Vecteurs, le cheval de trait R
Le type de vecteur est vraiment le coeur de R. Il est difficile d'imaginer du code R, ou même une session R interactive, qui n'implique pas de vecteurs.
Les éléments d'un vecteur doivent tous avoir le même mode ou le même type de données. Vous pouvez avoir un vecteur composé de trois chaînes de caractères (de type mode) ou trois entiers (de mode entier), mais pas un vecteur avec un élément integer et deux éléments de chaîne de caractères.
Nous parlerons plus de vecteurs dans le chapitre 2.


1.4.1.1 Scalaires
Les scalaires, ou nombres individuels, n'existent pas vraiment dans R. Comme mentionné plus haut, ce qui semble être des nombres individuels sont en réalité des vecteurs à un élément. considérer ce qui suit:

  1. > x <- 8
  2. > x
  3. [1] 8
Source code

Rappelons que [1] signifie ici que la rangée de chiffres suivante commence par l'élément 1 d'un vecteur - dans ce cas, x [i]. Ainsi, vous pouvez voir que R était considéré comme un vecteur, mais un vecteur avec un seul élément.


2 Chaînes de caractères
Les chaînes de caractères sont en fait des vecteurs mono-élément de caractère de mode (plutôt que mode numérique):

  1. > x <- c(5,12,13)
  2. > x
  3. [1] 5 12 13
  4. > length(x)
  5. [1] 3
  6. > mode(x)
  7. [1] "numeric"
  8. > y <- "abc"
  9. > y
  10. [1] "abc"
  11. > length(y)
  12. [1] 1
  13. > mode(y)
  14. [1] "character"
  15. > z <- c("abc","29 88")
  16. > length(z)
  17. [1] 2
  18. > mode(z)
  19. [1] "character"
Source code

Dans le premier exemple, nous créons un vecteur x de nombres, donc de mode numérique. Ensuite, nous créons deux vecteurs de caractère de mode: y est un vecteur à un élément (c'est-à-dire, une chaîne), et z est constitué de deux chaînes.
R possède diverses fonctions de manipulation de chaînes. Beaucoup traitent de l'assemblage de chaînes ou de leur démontage, comme les deux illustrés ici:

  1. > u <- paste("abc","de","f") # concatène les chaînes
  2. > u
  3. [1] "abc de f"
  4. > v <- strsplit(u," ") # fractionne la chaîne en fonction des blancs
  5. > v
  6. [[1]]
  7. [1] "abc" "de" "f"
Source code

 

 

3 Matrices
Une matrice R correspond au concept mathématique du même nom: un tableau rectangulaire de nombres. Techniquement, une matrice est un vecteur, mais avec deux
attributs supplémentaires: le nombre de lignes et le nombre de colonnes. Voici un exemple de code matriciel:

  1. > m <- rbind(c(1,4),c(2,2))
  2. > m
  3. [,1] [,2]
  4. [1,] 1 4
  5. [2,] 2 2
  6. > m %*% c(1,1)
  7. [,1]
  8. [1,] 5
  9. [2,] 4
Source code

Premièrement, nous utilisons la fonction rbind () pour construire une matrice à partir de deux vecteurs qui serviront de lignes, en stockant le résultat dans m. (Une fonction de correspondance, cbind (), combine plusieurs colonnes dans une matrice.) Ensuite, entrer le nom de la variable seule, qui, nous le savons, imprimera la variable, confirme que la matrice voulue a été produite. Enfin, nous calculons le produit matriciel du vecteur (1,1) et m. L'opérateur de multiplication matricielle, que vous pouvez connaître à partir des cours d'algèbre linéaire, est % *% dans R.
Les matrices sont indexées en utilisant un indice double, comme en C / C ++, bien que les indices commencent à 1 au lieu de 0.

  1. > m [1,2]
  2. [1] 4
  3. > m [2,2]
  4. [1] 2
Source code

Une caractéristique extrêmement utile de R est que vous pouvez extraire des sous-matrices à partir d'une matrice, tout comme vous extrayez des sous-vecteurs à partir de vecteurs. Voici un exemple:
  1. > m [1,] # rangée 1
  2. [1] 1 4
  3. > m [, 2] # colonne 2
  4. [1] 4 2
Source code

Nous parlerons plus de matrices dans le chapitre 3.


4 Listes
Comme un vecteur R, une liste R est un conteneur pour les valeurs, mais son contenu peut être des éléments de types de données différents. (Les programmeurs C / C ++ remarqueront l'analogie avec une structure en C). On accède aux éléments de liste en utilisant des noms en deux parties, qui sont indiqués par le symbole dollar $ dans R. Voici un exemple rapide:

  1. > x <- list(u=2, v="abc")
  2. > x
  3. $u
  4. [1] 2
  5. $v
  6. [1] "abc"
  7. > x$u
  8. [1] 2
Source code

L'expression x$u fait référence à la composante u de la liste x. Ce dernier contient un autre composant, noté v.
Une utilisation courante des listes consiste à combiner plusieurs valeurs en un seul paquet pouvant être retourné par une fonction. Ceci est particulièrement utile pour les fonctions statistiques, qui peuvent avoir des résultats élaborés. A titre d'exemple, considérons la fonction d'histogramme de base de R, hist (), présentée dans la Section 1.2. Nous avons appelé la fonction sur l'ensemble de données intégré dans le Nil de R:

Source code

Cela a produit un graphique, mais hist () renvoie également une valeur, que nous pouvons sauvegarder:
  1. > hn <- hist (Nile)
Source code

Qu'est-ce qui est en hn? Nous allons jeter un coup d'oeil:

  1. > print(hn)
  2. $breaks
  3. [1] 400 500 600 700 800 900 1000 1100 1200 1300 1400
  4. $counts
  5. [1] 1 0 5 20 25 19 12 11 6 1
  6. $intensities
  7. [1] 9.999998e-05 0.000000e+00 5.000000e-04 2.000000e-03 2.500000e-03
  8. [6] 1.900000e-03 1.200000e-03 1.100000e-03 6.000000e-04 1.000000e-04
  9. $density
  10. [1] 9.999998e-05 0.000000e+00 5.000000e-04 2.000000e-03 2.500000e-03
  11. [6] 1.900000e-03 1.200000e-03 1.100000e-03 6.000000e-04 1.000000e-04
  12. $mids
  13. [1] 450 550 650 750 850 950 1050 1150 1250 1350
  14. $xname
  15. [1] "Nile"
  16. $equidist
  17. [1] TRUE
  18. attr(,"class")
  19. [1] "histogram"
Source code

N'essayez pas de comprendre tout cela tout de suite. Pour l'instant, le fait est que, en plus de faire un graphique, hist () retourne une liste avec un certain nombre de composants. Ici, ces composants décrivent les caractéristiques de l'histogramme. Par exemple, le composant breaks nous indique où commencent et se terminent les bins dans l'histogramme, et le composant count est le nombre d'observations dans chaque bin.
Les concepteurs de R ont décidé de regrouper toutes les informations renvoyées par hist () dans une liste R, qui peut être consultée et manipulée par d'autres commandes R via le symbole du dollar.
Rappelez-vous que nous pourrions aussi imprimer hn simplement en tapant son nom:
> hn
Mais une alternative plus compacte pour imprimer des listes comme celle-ci est str ():

  1. > str(hn)
  2. List of 7
  3. $ breaks : num [1:11] 400 500 600 700 800 900 1000 1100 1200 1300 ...
  4. $ counts : int [1:10] 1 0 5 20 25 19 12 11 6 1
  5. $ intensities: num [1:10] 0.0001 0 0.0005 0.002 0.0025 ...
  6. $ density : num [1:10] 0.0001 0 0.0005 0.002 0.0025 ...
  7. $ mids : num [1:10] 450 550 650 750 850 950 1050 1150 1250 1350
  8. $ xname : chr "Nile"
  9. $ equidist : logi TRUE
  10. - attr(*, "class")= chr "histogram"
Source code

Ici, str signifie structure. Cette fonction montre la structure interne de n'importe quel objet R, pas seulement les listes.


1.4.5 Cadres de données
Un ensemble de données typique contient des données de différents modes. Dans un ensemble de données employé, par exemple, nous pouvons avoir des données de chaîne de caractères, telles que des noms d'employés, et des données numériques, telles que les salaires. Donc, bien qu'un ensemble de données de (disons)
50 employés avec 4 variables par travailleur ont l'aspect et la convivialité d'une matrice de 50 par 4, il n'est pas considéré comme tel dans R, car il mélange les types.
Au lieu d'une matrice, nous utilisons une trame de données. Une trame de données dans R est une liste, chaque composante de la liste étant un vecteur correspondant à une colonne de notre "matrice" de données. En effet, vous pouvez créer des trames de données injustes de cette façon:

  1. > d <- data.frame(list(kids=c("Jack","Jill"),ages=c(12,10)))
  2. > d
  3. kids ages
  4. 1 Jack 12
  5. 2 Jill 10
  6. > d$ages
  7. [1] 12 10
Source code

Généralement, cependant, les trames de données sont créées en lisant dans un ensemble de données à partir d'un fichier ou d'une base de données.
Nous parlerons plus au sujet des trames de données dans le chapitre 5.


1.4.6 Classes
R est un langage orienté objet. Les objets sont des instances de classes. Les classes sont un peu plus abstraites que les types de données que vous avez déjà rencontrés. Ici, nous verrons brièvement le concept en utilisant les classes S3 de R. (Le nom provient de leur utilisation dans l'ancien langage S, version 3, qui a été l'inspiration pour R.) La plupart de R est basé sur ces classes, et elles sont extrêmement simples. Leurs instances sont simplement des listes R mais avec un attribut supplémentaire: le nom de la classe.

Par exemple, nous avons noté plus haut que la sortie (non graphique) de la fonction histogramme hist () est une liste avec divers composants, tels que les composants break et count. Il y avait aussi un attribut, qui spécifiait la classe de la liste, à savoir l'histogramme.

  1. > print(hn)
  2. $breaks
  3. [1] 400 500 600 700 800 900 1000 1100 1200 1300 1400
  4. $counts
  5. [1] 1 0 5 20 25 19 12 11 6 1
  6. ...
  7. ...
  8. attr(,"class")
  9. [1] "histogram"
Source code

À ce stade, vous vous demandez peut-être: «Si les objets de classe S3 ne sont que des listes, pourquoi en avons-nous besoin?» La réponse est que les classes sont utilisées par des fonctions génériques. Une fonction générique représente une famille de fonctions, toutes servant un but similaire, mais chacune étant appropriée à une classe spécifique.
Une fonction générique couramment utilisée est summary (). Un utilisateur R qui veut utiliser une fonction statistique, comme hist (), mais qui ne sait pas comment gérer sa sortie (qui peut être volumineuse), peut simplement appeler summary () sur la sortie, qui n'est pas seulement une liste mais une instance d'une classe S3.
La fonction summary (), à son tour, est en réalité une famille de fonctions de synthèse, chacune gérant des objets d'une classe particulière. Lorsque vous appelez summary () sur une sortie, R recherche une fonction de résumé appropriée à la classe en cours et l'utilise pour donner une représentation plus conviviale de la liste. Ainsi, calling summary () sur la sortie de hist () produit un résumé adapté à cette fonction, et l'appel de summary () sur la sortie de la fonction de régression lm () produit un résumé approprié pour cette fonction.
La fonction plot () est une autre fonction générique. Vous pouvez utiliser plot () sur n'importe quel objet R. R trouvera une fonction de traçage appropriée basée sur la classe de l'objet.
Les classes sont utilisées pour organiser les objets. Conjointement avec les fonctions génériques, ils permettent de développer un code flexible pour gérer une variété de tâches différentes mais connexes. Le chapitre 9 couvre les cours en profondeur.

 

  1. Introduction aux fonctions avec R