• 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

 

 

Écriture à l'étage dans R

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

Comme mentionné précédemment, le code qui existe à un certain niveau de la hiérarchie de l'environnement a au moins un accès en lecture à toutes les variables aux niveaux au-dessus.
En revanche, l'accès en écriture direct aux variables à des niveaux supérieurs via l'opérateur standard <- n'est pas possible.
Si vous souhaitez écrire dans une variable globale ou plus généralement dans une hiérarchie d'environnement plus élevée que le niveau auquel votre instruction d'écriture existe, vous pouvez utiliser l'opérateur de super-affectation, << - ou l'attribut assign () fonction. Parlons d'abord de l'opérateur de super-assignement.


1 Écriture à des non-interlocuteurs avec l'opérateur de super-assignement
Considérez le code suivant:

  1. > two <- function(u) {
  2. + u <<- 2
  3. + z <- 2
  4. *
  5. z
  6. *
  7. u
  8. +}
  9. >x<-1
  10. >z<-3
  11. >u
  12. Error: object "u" not found
  13. > two(x)
  14. >x
  15. [1] 1
  16. >z
  17. [1] 3
  18. >u
  19. [1] 2
Source code
Regardons l'impact (ou non) sur les trois variables de haut niveau x, z et u:
• x: Même si x était l'argument réel de two () dans l'exemple, il conservait la valeur 1 après l'appel. C'est parce que sa valeur 1 a été copiée dans l'argument formel u, qui est traité comme une variable locale dans la fonction. Ainsi, quand vous avez changé, x n'a pas changé avec elle.
• z: Les deux valeurs z sont totalement indépendantes les unes des autres: l'une est de niveau supérieur et l'autre est locale à two (). Le changement de la variable locale n'a aucun effet sur la variable globale. Bien sûr, avoir deux variables portant le même nom n'est probablement pas une bonne pratique de programmation.
• u: La valeur u n'existait même pas en tant que variable de niveau supérieur avant notre appel two (), d'où le message d'erreur "not found". Cependant, il a été créé en tant que variable de niveau supérieur par l'opérateur de super-assignement dans les deux (), comme confirmé après l'appel.
Bien que << - soit typiquement utilisé pour écrire sur des variables de haut niveau, comme dans notre exemple, techniquement, il fait quelque chose de différent. L'utilisation de cet opérateur pour écrire dans une variable w entraînera une recherche dans la hiérarchie de l'environnement, s'arrêtant au premier niveau auquel une variable de ce nom est rencontrée. Si aucun n'est trouvé, le niveau sélectionné sera global. Regardez ce qui se passe dans ce petit exemple:

  1. >f
  3. }
  4. inc <- function() {x <<-x+1}
  5. x<-3
  6. inc()
  8. > f()
  9. [1] 4
  10. >x
  11. Error: object 'x' not found
Source code
Ici, inc () est défini dans f (). Lorsque inc () est en cours d'exécution et que l'interpréteur R voit une super-affectation à x, il commence à remonter la hiérarchie. Au premier niveau, l'environnement dans f () - il trouve un x, et donc x est celui qui est écrit, pas x au niveau supérieur.


2 Ecriture sur nonlocaux avec assign ()
Vous pouvez également utiliser la fonction assign () pour écrire dans des variables de niveau supérieur. Voici une version modifiée de l'exemple précédent:

  1. > two
  3. assign("u",2
  4. *
  5. u,pos=.GlobalEnv)
  6. z<-2
  7. *
  8. z
  9. }
  10. > two(x)
  11. >x
  12. [1] 1
  13. >u
  14. [1] 2
Source code
Ici, nous avons remplacé l'opérateur de super-assignement par un appel à assign (). Cet appel demande à R d'attribuer la valeur 2 * u (c'est le local u) à une variable u plus haut dans la pile d'appels, en particulier dans l'environnement de niveau supérieur. Dans ce cas, cet environnement est seulement un niveau d'appel plus élevé, mais si nous avions une chaîne d'appels, cela pourrait être beaucoup plus haut.
Le fait que vous référenciez des variables en utilisant des chaînes de caractères dans assign () peut être utile. Rappelons l'exemple du chapitre 5 concernant l'analyse des schémas d'embauche de diverses grandes entreprises. Nous voulions former un cadre de sous-données pour chaque entreprise, extrait de la base de données globale, pour l'ensemble de 2006. Pour l'instant, considérez cet appel:

  1. makecorpdfs(c("MICROSOFT CORPORATION","ms","INTEL CORPORATION","intel","
  2. SUN MICROSYSTEMS, INC.","sun","GOOGLE INC.","google")
Source code
Cela extrayait d'abord tous les enregistrements Microsoft de la base de données globale, en nommant le cadre de sous-données résultant ms2006. Il créerait alors intel2006 pour Intel, et ainsi de suite. Voici le code (changé en forme de fonction, pour plus de clarté):

  1. makecorpdfs <- function(corplist) {
  2. for (i in 1:(length(corplist)/2)) {
  3. }
  4. corp <- corplist[2
  5. *
  6. i-1]
  7. newdtf <- paste(corplist[2
  8. *
  9. i],"2006",sep="")
  10. assign(newdtf,makecorp(corp),pos=.GlobalEnv)
  11. }
Source code
Dans l'itération i = 1, le code utilise paste () pour épisser les chaînes "ms" et "2006", ce qui donne "ms2006", le nom désiré.