<jupyter_start><jupyter_text>[pour Statistique et Science des Données](https://github.com/wikistat/Intro-Python)  Introduction à  **Résumé** Tutoriel d'initiation qui précise l'environnement de travail (packages, répertoire courant). Il propose de manipuler les différents types d'objets  existants dans R et décrit quelques outils d'importation/exportation de données.   1 EnvironnementQuelques compléments pour une utilisation facile concernant le chargement de librairies complémentaires et le répertoire de travail. 1.1 LibrairiesLa liste complète des *packages* ou librairies disponibles est consultable sur le site du [CRAN](http://cran.cict.fr/web/packages/index.html).  L'installation d'un package supplémentaire peut se faire via le menu de Rstudio `Packages>Installer le(s) package(s)` et en choisissant un site miroir du CRAN ou directement avec la fonction `install.packages("nomPackage")`. Celui-ci est installé dans un répertoire de l'utilisateur qui n'a donc pas besoin de dorits d'administration de la machine. 1.2 Répertoire courantPour pouvoir récupérer des données, il est utile de connaître le répertoire de travail, c'est-à-dire le répertoire sous lequel les divers résultats seront sauvegardés par défaut. Ce dernier s'obtient à l'aide la commande:<jupyter_code>getwd()<jupyter_output><empty_output><jupyter_text>Tandis que la commande `setwd("C:/User/Mes documents/CoursR")`change de répertoire courant. C'est également possible à partir du menu de RStudio (`Set Sorking Directory`). 2 Structures de donnéesSous R, les éléments de base sont des objets : vecteurs, matrices, listes..., sur lesquels sont appliquées des fonctions qui fournissent des résultats numériques et graphiques. Ces objets se différencient par leur *mode* décrivant leur contenu, et leur *classe* décrivant leur structure. Les objets atomiques sont de mode *homogène* et les objets récursifs (listes) sont de mode *hétérogène*. Les différents modes sont `null` (objet vide), `logical, numeric, complex, character`. Les classes d'objets les plus courantes sont : `vector, matrix, array, factor, data.frame, list`. On peut avoir des vecteurs, matrices, tableaux, ... de mode `null` (objet vide), `logical` (`TRUE, FALSE, NA`), `numeric, complex`, character tandis que les listes et les *data frame* peuvent être composés d'éléments hétérogènes.**Attention** Une confusion entre classes d'objets dans l'appel d'une fonction est la source d'erreur largement la plus fréquente.  2.1 Opérations sur les scalairesEntrer les commandes en identifiant  les différents types de données<jupyter_code>2+2
exp(10)
a = log(2)
b <- cos(10) #  "<-" est équivalent à "="
a+b
a
b
2==3
b = 2<3 ; b
ls()  # variables de l'environnement de travail
rm(a) # effacer une ou plusieurs variables
a
a="texte"
a<jupyter_output><empty_output><jupyter_text>2.2 Type caractèreManipulation de Chaînes de caractères.<jupyter_code>c="ABCdef";nchar(c);c
is.character(c)
substr(c,1,3)
# changer la casse
tolower(c)
toupper(c)
# coller
paste("alpha",c,sep="-")<jupyter_output><empty_output><jupyter_text>2.3 Type booléen et opérateurs logiquesLes variables booléennes prennent les valeurs `TRUE` ou `FALSE` ; les opérateurs de comparaison  ` =, !=, ==` retournent ces valeurs tandis  que `&, |, !` sont les opérateurs logiques "et", "ou", "non".<jupyter_code>a = 3 ; b = 6
a<=b
a!=b
(b - 3 == a) & ( b>= a)
(b  == a) | (b>=a)<jupyter_output><empty_output><jupyter_text>3.4 Les vecteurs (`vector`)Un vecteur regroupe des éléments de même mode. La création d'un vecteur peut se faire par la commande `c(e1,e2,...)`. On peut également générer une séquence avec la commande `seq(a,b,t)` débutant par `a` inférieure ou égale à `b` et de pas `t` ; `rep(x,n)` est un vecteur répétant *n* fois l'élément `x`.<jupyter_code>d = c(2,3,5,8,4,6); d
is.vector(d)
c(2,5,"texte")<jupyter_output><empty_output><jupyter_text>Séquences et répétitions.<jupyter_code>1:10 
seq(from=1,to=20,by=2)
seq(1,20,by=5)
seq(1,20,length=5)
rep(5,times=10)
rep(c(1,2),3)
rep(c(1,2),each=3)
e = rep(1,10); e<jupyter_output><empty_output><jupyter_text>Extraction dans un vecteur par `[]` et valeurs manquantes.<jupyter_code>d[2];d[2:3];d[-3]
# attention aux indices :
d[-1:2];d[-(1:2)] 
# NA (Not Available) signale une donnée manquante
d[3]=NA;d;summary(d)
is.na(d);help(NA)
# fonctions "any" et "all"
any(is.na(d));all(is.na(d))<jupyter_output><empty_output><jupyter_text>Labels et opérations.<jupyter_code>f = c(a=12,b=26,c=32,d=41);f
names(f);f["a"]
names(f)=c("a1","a2","a3","a4")
f>30;f[f>30]  # noter les différences
which(f>30)
f[2] = 22;f+100;f+d  # un problème ?
cos(f);length(f);sum(f)
t(f) # transposition
e=rep(2,4); 2*e; 2+e
e+f ; e*f # opérations terme à terme
t(f)%*%e # produit scalaire
a<-c(3,-1,5,2,-7,3,9)
abs(a);sort(a);order(a)<jupyter_output><empty_output><jupyter_text>3.5 FacteursUn facteur est un vecteur avec une liste prédéfinie de valeurs, les niveaux (\emph{levels}). Cela correspond typiquement à une variable qualitative nominale.<jupyter_code>vect=c("a","b","c","b","b","a")
vect
vect.f=as.factor(vect)
vect.f
as.integer(vect.f)
as.character(vect.f)<jupyter_output><empty_output><jupyter_text>3.6 Les matrices (`matrix`)Comme les vecteurs, les matrices sont de mode quelconque mais necontiennent que des éléments de même nature. Pour créer une matrice, on utilisela commande `matrix(vec,nrow=n,ncol=p)` où `vec` est le vecteurcontenant les éléments de la matrice de taille *n* par *p*, qui seront rangés encolonne sauf si l'option `byrow=T` est utilisée.<jupyter_code>A = matrix(1:15,ncol=5);A
B = matrix(1:15,nc=5,byrow=T)
B2=B;B2[1,1]="toto";B2
cbind(A,B);rbind(A,B) # concaténations
A[1,3];A[,2];B[2,] # composants
A[1:3,2:4]<jupyter_output><empty_output><jupyter_text>Opérations sur les matrices<jupyter_code>g = seq(0,1,length=20)
C = matrix(g,nrow=4)
dim(C)
C[C[,1]>0.1,]  # * voir question ci-dessous
# ranunif : tirage aléatoire uniforme
D = matrix(runif(16),ncol=4)
D>0.5
D[D[,1]>0.5,2]=0   # ** voir question ci-dessous
A+B;A*B  #  opérations terme à terme
cos(A); cos(A[1:2,1:2])
# inversion
solve(A);solve(A[1:2,1:2])
# produit matriciel
t(A) %*% B
A[1:2,1:2] %*% B[1:2,1:3]
t(B); diag(A)
apply(A,2,sum)   # *** voir question ci-dessous
apply(D,1,max)
# Eléments propres
s=eigen(A[1:2,2:3])
s$values
s$vectors<jupyter_output><empty_output><jupyter_text>**Questions**- Que font {`rbind`} et {`cbind`}?- Décortiquer la ligne ci-dessus marquée `*` et décrire ce qu'elle fait.- Même chose avec `**`. - Que renvoie la ligne `***`? **Réponses**- `rbind` et `cbind` collent deux vecteurs ou matrices respectivement en ligne ou en colonne.- `C[C[,1]>0.1,]` peut se décomposer ainsi:	- `C[,1]` extrait la première colonne de la matrice `C`	- `C[,1]>0.1` renvoie un vecteur logique de longueur le nombre de lignes de C contenant `TRUE` si la valeur est supérieure à 0.1 et `FALSE` sinon.	- `C[C[,1]>0.1,]` extrait de la matrice `C` les lignes où les éléments sur la première colonne sont supérieurs à 0.1 et toutes les colonnes si rien après la virgule.- `**` extrait de la colonne 2 de la matrice `D`, les lignes où l'élément sur la première colonne est supérieur à 0.5 et met à 0 ces éléments.- `***` renvoie un vecteur de longueur 5 (le nombre de colonnes de `A`) dont chaque élément est la somme des éléments d'une colonne de A.**Noter** l'importance de ces différentes "astuces" pour éviter des boucles `for` dont l'*usage est fortement déconseillé* avec un langage interprété sous peine de plomber les temps d'exécution. 3.6 Les tableaux (`array`)Les tableaux sont des matrices de dimensions supérieures à 2. On peut les générer à partir de la commande `array(vec,c(n,p,q,...))` où `vec` est le vecteur contenant les éléments du tableau et l'argument `c(n,p,q,...)` désigne les dimensions du tableau : *n* lignes, *p* colonnes, *q* matrices, ...<jupyter_code>array(c(1:8, rep(1,8),seq(0,1,len=8)), dim = c(2,4,3))
E = .Last.value
E[, , 1]
dim(E);length(E);nrow(E);ncol(E)
E+10
H=array(1:12,c(2,3,2))
apply(H,1,mean)
apply(H,2,mean)
apply(H,3,mean)<jupyter_output><empty_output><jupyter_text>**Questions**- Expliquer les résulats des 3 appels à la fonction `apply()`.- Créer un `array` à 4 dimensions et calculer la somme des éléments dans toutes les dimensions.**Réponses**- Dans le premier cas, on calcule la moyenne de tous les éléments ligne par ligne. Les éléments de la ligne 1 sont tous les élements de la tranche supérieure horizontale du parallélépipède `H` (1,3,5,7,9,11) ; de la tranche inférieure pour la ligne 2 (2,4,6,8,10,12). Dans le deuxième cas, le calcul est effectué colonne par colonne, le vecteur résultat est donc de longueur 3 ; il contient la moyenne des éléments des 3 tranches verticales (gauche - [1,2,7,8], centre - [3,4,9,10] et droite - [5,6,11,12]). Dans le troisième cas, le calcul de moyenne est fait sur les 2 tranches verticales "avant" (1,2,3,4,5,6) et "arrière" (7,8,9,10,11,12).- Code:<jupyter_code>H2=array(1:24,c(2,3,2,2)) # crée un array à 4 dimensions équivalent dans cet exemple à 2 tableaux H 
apply(H,1,sum)
apply(H,2,sum)
apply(H,3,sum)
apply(H,4,sum)<jupyter_output><empty_output><jupyter_text>3.7 Les listes (`list`)Une liste est une collection ordonnée d'objets qui peuvent être de classes différentes. Les listes sont en particulier utilisées par certaines fonctions (cf. tutoriel "Programmation") pour renvoyer des résultats complexes sous formed'un seul objet. On utilise la fonction `list(nom1=el1,nom2=el2,...)` pour générer une liste. On peut accéder à chaque élément de la liste à l'aide de son index entre double crochets `[[...]]`, ou par son nom précédé du signe `$`.<jupyter_code>x = list("toto",1:8);x
x[[1]];x[[1]]+1;x[[2]]+10 # *
y = list(matrice=D,vecteur=f,texte="toto",scalaire=8)
names(y);y[[1]]
y$matrice;y$vec
y[c("texte","scal")] # **
y[c("texte","scalaire")]
length(y);length(y$vecteur)
cos(y$scalaire)+y[[2]][1]
summary(y)<jupyter_output><empty_output><jupyter_text>**Questions**- Quel est le problème avec la ligne * ?- Et avec la ligne ** ?**Réponses**- C'est la 2ème commande de la ligne qui renvoie une erreur. On cherche à ajouter 1 à un élément qui n'est pas numérique.- Aucun composant de la liste ne s'appelle `scal` ("lettre à lettre").  3.8 Tableau de données (`data.frame`)Un *data frame* est analogue à une matrice dont les colonnes peuvent être *hétérogènes*. Un *tableau de données* est un ensemble de vecteurs, une *liste*, rangés colonne par colonne, chaque colonne correspondant à une variable, chaque ligne à un individu. Le type *data frame* est très important, c'est **la façon** de gérer les données à étudier sous R lors d'une étude statistique.Un tableau de données, est créé en regroupant des variables (vecteurs) de même longueur à l'aide de la commande  `data.frame(nom1=var1,nom2=var2,...)`. Une matrice est transformée en un tableau de données en utilisant la commande `as.data.frame(mat)`.<jupyter_code>taille = runif(12,150,180)
masse = runif(12,50,90)
sexe = rep(c("M","F","F","M"),3)
H = data.frame(taille,masse,sexe)
H
summary(H)
# analogies entre data.frame, list et matrix
H[1,];H$taille;H$sexe
is.data.frame(H); is.matrix(H)
MH = as.matrix(H)
summary(MH)
as.list(H)
rm(taille);taille # (1)
H$taille
attach(H);taille  # (2)
search()          # (3)
detach();taille   # (4)<jupyter_output><empty_output><jupyter_text>**Questions**- Tester la fonction `summary` sur d'autres types d'objets.- Quel est l'effet de la conversion "forcée" du `data.frame` en matrice opérée par la fonction `as.matrix()`?- Commenter l'enchaînement des lignes 1 à 4. Quel est l'effet de la fonction `attach`? De la fonction `search`? De la fonction `detach`?- Extraire la masse des individus dont la taille est supérieure à 160. - Extraire la masse et le sexe de ces mêmes individus.- Extraire la taille des individus de sexe masculin dont la masse est inférieure à 70. C'est possible en une seule ligne (voir l'opérateur `&`, `help("&")`).**Réponses**<jupyter_code># 1. Fonction summary
vec=c(2,5,3,6,5,4,1,8);summary(vec)
mat=matrix(1:20,nc=4,nr=5)
summary(mat);summary(c(mat))<jupyter_output><empty_output><jupyter_text>2. La conversion en matrice implique que tous les éléments sont désormais du mode `character`. La fonction `summary()` ne calcule plus des indicateurs numériques pour les colonnes `taille` et `masse`.3. Enchaînement des lignes	- (1) Supprime l'objet `taille` dans l'espace de travail courant ; l'objet `taille` n'est plus reconnu.	- (2) Attache le data.frame `H` ; les composants de `H` deviennent accessibles directement.	- (3) `search()` permet de lister les environnements liés à l'espace de travail courant.	- (4) Détache l'environnement en position 2 dans la liste de `search()`.<jupyter_code># 4.
H[H$taille>160,2]  
# 5.
H[H$taille>160,2:3]  
# 6.
H[H$masse<70 & H$sexe=="M",1]<jupyter_output><empty_output><jupyter_text>4 Entrée / Sortie 4.1 Importation d'un jeu de données`Tab1 = read.table("Tableau.dat")` lit le fichier nommé `Tableau.dat` pour créer le *data frame* `Tab1` en supposant que le fichier est bien dans le répertoire courant. Sinon il faut préciser le chemin. `help(read.table)` fournit la liste des nombreuses options de cette fonction très utile. Les fonctions `read.csv` et `read.csv2` en sont des cas particuliers, c'est-à-dire avec des options spécifiques (caractère séparateur, marque décimale) adaptées aux fichiers lus / écrits par des tableurs en format `.csv`.Utiliser un éditeur de texte pour créer les quatre fichiers `fic1.txt` à `fic4.txt` ci-dessous  en respectant scrupuleusement la ponctuation.			5,2.5,3.8 			8,3.2,3.4 			12,4.6,5 N.B. séparateur par caractère de tabulation pour le fichier `fic2.txt`			5       2.5     3.8  			8       3.2     3.4  			12      4.6     5  			X1;X2;X3  			5;2.5;3.8  			8;3.2;3.4  			12;4.6;5	            			5;2,5;3,8  			8;3,2;3,4  			12;4,6;5 Comparer les modes de lecture de fichiers en fonction du type, des séparateurs et de la présence de la première ligne de noms des variables.<jupyter_code>fic1=read.table("fic1.csv",sep=",")
fic1
fic1b=read.csv("fic1.csv")
fic1b
fic1b=read.csv("fic1.csv",header=FALSE)
fic1b<jupyter_output><empty_output><jupyter_text>**Questions**Importer les fichiers {\tt fic2.txt}, {\tt fic3.txt} et {\tt fic4.txt}.**Réponses**<jupyter_code>fic2 = read.table("fic2.txt")
fic3 = read.table("fic3.txt",header=T,sep=";")
fic4 = read.table("fic4.txt",sep=";",dec=",")<jupyter_output><empty_output><jupyter_text>4.2 Exportation d'objets REcriture dans un fichier et traces des exécutions.<jupyter_code>A=seq(1,10,l=50)
write.table(A,"A.txt")
sink("A2.txt")  # Début, ouverture du fichier
A;summary(A)
sink()  # arrêt et fermeture du fichier
summary(A)<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.13681048607318405, 'fraction_numerical': 0.03229109776078645, 'mean_word_length': 5.560232870577698, 'pattern_counts': {'":': 0, '<': 87, '<?xml version=': 0, '>': 95, 'https://': 1, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '20', 'dir': 'jupyter-structured-clean-dedup', 'id': '311236', 'license': 'MIT', 'n_tokens_mistral': 5851, 'n_tokens_neox': 5762, 'n_words': 1692, 'path': 'cal2-intro-R.ipynb', 'repo_name': 'PhilBesse/Intro-R', 'size': '14648'}