• analyse-de-donnes-cestad
  • analytics_tools_original
  • data-minig1
  • data-minig2
  • Data-Mining-1030
  • Big-data-azzurro
  • marketing-statistics
Enquêtes
Collete des données
Traitement des données
Analyse des données
 
Programmation
Programmation statistique
Developpement des macros
Modélisation et plus encore
 
Data Mining
Exploration des données
Modélisation prédictive
Big Data
 
   Formations
Formations certifiantes
Formations à la carte
Semilaires et conférences

 

 

Les fonctions sont des objets dans R

Détails
Catégorie : Structure de la programmation R

Les fonctions R sont des objets de première classe (de la classe "fonction", bien sûr), ce qui signifie qu'ils peuvent être utilisés pour la plupart comme d'autres objets. Cela se voit dans la syntaxe de la création de fonctions:

  1. > g <- function(x) {
  2. + return(x+1)
  3. +}
Source code

Ici, function () est une fonction R intégrée dont le travail est de créer des fonctions! Sur le côté droit, il y a vraiment deux arguments pour function (): La première est la liste des arguments formels pour la fonction que nous créons - ici, seulement x - et la seconde est le corps de cette fonction - ici, juste le retour d'état unique (x + 1). Ce second argument doit être de classe "expression". Donc, le fait est que le membre de droite crée un objet de fonction, qui est ensuite assigné à g.
Par ailleurs, même le "{" est une fonction, comme vous pouvez le vérifier en tapant ceci:

  1. > ?"{"
Source code
Son travail est de faire une seule unité de ce qui pourrait être plusieurs déclarations.
Ces deux arguments pour function () peuvent ensuite être accédés via les fonctions R formals () et body (), comme suit:

  1. > formals(g)
  2. $x
  3. > body(g)
  4. {
  5. return(x + 1)
  6. }
Source code
Rappelez-vous que lorsque vous utilisez R en mode interactif, il suffit de taper le nom d'un objet pour imprimer cet objet à l'écran. Les fonctions ne font pas exception, puisqu'elles sont des objets comme n'importe quoi d'autre.

  1. >g
  3. return(x+1)
  4. }
Source code
C'est utile si vous utilisez une fonction que vous avez écrite mais dont vous avez oublié les détails. L'impression d'une fonction est également utile si vous n'êtes pas sûr de ce que fait une fonction de bibliothèque R. En regardant le code, vous pouvez le comprendre mieux. Par exemple, si vous n'êtes pas sûr du comportement exact de la fonction graphique abline (), vous pouvez parcourir son code pour mieux comprendre comment l'utiliser.

  2. function (a = NULL, b = NULL, h = NULL, v = NULL, reg = NULL,
  3. coef = NULL, untf = FALSE, ...)
  4. {
  5. ...
  6. ...
  7. int_abline <- function(a, b, h, v, untf, col = par("col"),
  8. lty = par("lty"), lwd = par("lwd"), ...) .Internal(abline(a,
  9. b, h, v, untf, col, lty, lwd, ...))
  10. if (!is.null(reg)) {
  11. if (!is.null(a))
  12. }
  13. warning("'a' is overridden by 'reg'")
  14. a<-reg
  15. if (is.object(a) || is.list(a)) {
  16. p <- length(coefa <- as.vector(coef(a)))
Source code
Si vous souhaitez afficher une longue fonction de cette manière, lancez-la à travers la page ():

Source code
Une alternative est de le modifier en utilisant la fonction edit (), dont nous parlerons dans la section 7.11.2.
Notez cependant que certaines des fonctions intégrées les plus fondamentales de R sont écrites directement dans C et ne sont donc pas visibles de cette manière. Voici un exemple:

  1. > sum
  2. function (..., na.rm = FALSE) .Primitive("sum")
Source code
Les fonctions étant des objets, vous pouvez également les assigner, les utiliser comme arguments pour d'autres fonctions, etc.

  1. > f1 <- function(a,b) return(a+b)
  2. > f2 <- function(a,b) return(a-b)
  3. >f<-f1
  4. > f(3,2)
  5. [1] 5
  6. >f<-f2
  7. > f(3,2)
  8. [1] 1
  9. > g <- function(h,a,b) h(a,b)
  10. > g(f1,3,2)
  11. [1] 5
  12. > g(f2,3,2)
  13. [1] 1
Source code
Et comme les fonctions sont des objets, vous pouvez parcourir une liste composée de plusieurs fonctions. Cela serait utile, par exemple, si vous souhaitiez écrire une boucle pour tracer un certain nombre de fonctions sur le même graphe, comme suit:

  1. > g1 <- function(x) return(sin(x))
  2. > g2 <- function(x) return(sqrt(x^2+1))
  3. > g3 <- function(x) return(2
  4. *
  5. x-1)
  6. > plot(c(0,1),c(-1,1.5)) # prepare the graph, specifying X and Y ranges
  7. > for (f in c(g1,g2,g3)) plot(f,0,1,add=T) # add plot to existing graph
Source code
Les fonctions formals () et body () peuvent même être utilisées comme fonctions de remplacement. Nous discuterons des fonctions de remplacement dans la Section 7.10, mais pour l'instant, réfléchissez à la façon dont vous pourriez modifier le corps d'une fonction par affectation:

  1. > g <- function(h,a,b) h(a,b)
  2. > body(g) <- quote(2
  3. >g
  5. 2
  6. *
  7. x+3
  8. > g(3)
  9. [1] 9
  10. *
  11. x+3)
Source code
La raison pour laquelle quote () était nécessaire est que techniquement, le corps d'une fonction a la classe "call", qui est la classe produite par quote (). Sans l'appel à citer (), R essaierait d'évaluer la quantité 2 * x + 3. Donc, si x avait été défini et égal à 3, par exemple, nous assignerions 9 au corps de g (), certainement pas ce que nous voulons. D'ailleurs, puisque * et + sont des fonctions (comme décrit dans la section 2.4.1), en tant qu'objet de langage, 2 * x + 3 est en effet un appel entrant, c'est un appel de fonction imbriqué dans un autre.