add french translation of R

1 files changed, 154 insertions, 132 deletions

diff --git a/fr-fr/r-fr.html.markdown b/fr-fr/r-fr.html.markdown
index 8db78ef3..d6879c1f 100644
--- a/fr-fr/r-fr.html.markdown
+++ b/fr-fr/r-fr.html.markdown
@@ -9,9 +9,9 @@ filename: learnr-fr.r
 ---
 
 R est un langage de programmation statistique. Il dispose de nombreuses
-librairies pour le téléchargement et le nettoyage des ensembles de données,
-l'exécution de procédures statistiques, et pour faire des graphiques.
-On peut également exécuter les commmandes R à l'aide d'un document LaTeX.
+librairies pour le téléchargement et le nettoyage d'ensembles de données,
+l'exécution de procédures statistiques, et la réalisation de graphiques.
+On peut également exécuter les commmandes `R` au sein d'un document LaTeX.
 
 
 ```r
@@ -25,30 +25,30 @@ On peut également exécuter les commmandes R à l'aide d'un document LaTeX.
 
 
 
-#############################################################################
-# Les choses que vous pouvez faire sans rien comprendre à la programmation
-#############################################################################
+########################################################################
+# Les choses que vous pouvez faire sans rien comprendre
+# à la programmation
+########################################################################
 
-# In this section, we show off some of the cool stuff you can do in
 # Dans cette section, nous vous montrons quelques trucs cools que vous
 # pouvez faire avec R sans rien comprendre à la programmation.
 # Ne vous inquiétez pas si vous ne comprenez pas tout ce que le code fait.
 # Profitez simplement !
 
-data()	        # parcours les ensembles de données préchargées
-data(rivers)	# obtiens celui-ci: "Lengths of Major North American Rivers"
-ls()	        # notez que "rivers" apparaît maintenant dans votre espace de travail
-head(rivers)	# Jetez un coup d'oeil à l'ensemble de données
+data()          # parcours les ensembles de données préchargées
+data(rivers)	# récupère ceci : "Lengths of Major North American Rivers"
+ls()            # notez que "rivers" apparaît maintenant dans votre espace de travail
+head(rivers)	# donne un aperçu des données
 # 735 320 325 392 524 450
 
 length(rivers)	# Combien de rivers ont été mesurées ?
 # 141
-summary(rivers) # quelles sont les statistiques sommaires ?
-#   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
-#  135.0   310.0   425.0   591.2   680.0  3710.0 
+summary(rivers) # Quels sont les principales données statistiques ?
+#   Min. 1st Qu.  Median    Mean 3rd Qu.    Max.
+#  135.0   310.0   425.0   591.2   680.0  3710.0
 
 # Fait un diagramme à tiges et à feuilles (visualisation de données de
-types histogramme)
+# types histogramme)
 stem(rivers)
 
 
@@ -64,23 +64,24 @@ stem(rivers)
 #  14 | 56
 #  16 | 7
 #  18 | 9
-#  20 | 
+#  20 |
 #  22 | 25
 #  24 | 3
-#  26 | 
-#  28 | 
-#  30 | 
-#  32 | 
-#  34 | 
+#  26 |
+#  28 |
+#  30 |
+#  32 |
+#  34 |
 #  36 | 1
 
-stem(log(rivers)) # Notez que les données ne sont ni normales ni lognormales !
-# Prenez-ça les fondamentalistes, la courbe en cloche
+stem(log(rivers)) # Notez que les données ne sont ni normales
+# ni lognormales !
+# Prenez-ça, la courbe en cloche
 
 #  Le point décimal est à 1 chiffre à gauche du |
 #
 #  48 | 1
-#  50 | 
+#  50 |
 #  52 | 15578
 #  54 | 44571222466689
 #  56 | 023334677000124455789
@@ -95,14 +96,14 @@ stem(log(rivers)) # Notez que les données ne sont ni normales ni lognormales !
 #  74 | 84
 #  76 | 56
 #  78 | 4
-#  80 | 
+#  80 |
 #  82 | 2
 
 # Fais un histogramme :
-hist(rivers, col="#333333", border="white", breaks=25) # amusez-vous avec ces parenthèses
+hist(rivers, col="#333333", border="white", breaks=25) # amusez-vous avec ces paramètres
 hist(log(rivers), col="#333333", border="white", breaks=25) # vous ferez plus de tracés plus tard
 
-# Ici d'autres données nettes qui viennent préchargées. R en a des tonnes.
+# Ici d'autres données qui viennent préchargées. R en a des tonnes.
 data(discoveries)
 plot(discoveries, col="#333333", lwd=3, xlab="Year",
      main="Number of important discoveries per year")
@@ -118,7 +119,7 @@ sort(discoveries)
 # [76]  4  4  4  4  5  5  5  5  5  5  5  6  6  6  6  6  6  7  7  7  7  8  9 10 12
 
 stem(discoveries, scale=2)
-# 
+#
 #  Le point décimale est à la |
 #
 #   0 | 000000000
@@ -132,19 +133,20 @@ stem(discoveries, scale=2)
 #   8 | 0
 #   9 | 0
 #  10 | 0
-#  11 | 
+#  11 |
 #  12 | 0
 
 max(discoveries)
 # 12
 summary(discoveries)
-#   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
-#    0.0     2.0     3.0     3.1     4.0    12.0 
+#   Min. 1st Qu.  Median    Mean 3rd Qu.    Max.
+#    0.0     2.0     3.0     3.1     4.0    12.0
 
-# Lance un dès quelques fois
+# Lance un dès plusieurs fois
 round(runif(7, min=.5, max=6.5))
 # 1 4 6 1 4 6 4
-# Vos numéros diffèreront des miens à moins que nous mettions le même random.seed(31337)
+# Vos numéros diffèreront des miens à moins que nous mettions
+# le même random.seed(31337)
 
 # Dessine à partir d'une normale Gaussienne 9 fois
 rnorm(9)
@@ -153,15 +155,9 @@ rnorm(9)
 
 
 
-##################################################
+##############################################################
 # les types de données et l'arithmétique de base
-##################################################
-
-# Now for the programming-oriented part of the tutorial.
-# In this section you will meet the important data types of R:
-# integers, numerics, characters, logicals, and factors.
-# There are others, but these are the bare minimum you need to
-# get started.
+##############################################################
 
 # Maintenant pour la partie orientée programmation du tutoriel.
 # Dans cette section vous rencontrerez les types de données importants de R :
@@ -171,22 +167,23 @@ rnorm(9)
 # Les entiers de mémoire longue sont écrit avec L
 5L # 5
 class(5L) # "integer"
-# (Essayez ?class pour plus d'information sur la fonction class().)
-# Avec R, chaque valeur seule, comme 5L, est considéré comme un vecteur de longueur 1
+# (Essayez ?class pour plus d'informations sur la fonction class().)
+# Avec R, chaque valeur seule, comme 5L, est considéré comme
+# un vecteur de longueur 1
 length(5L) # 1
-# On peut avoir un vecteur d'entiers avec une longueur > 1 aussi :
+# On peut avoir un vecteur d'entiers avec une longueur > 1 :
 c(4L, 5L, 8L, 3L) # 4 5 8 3
 length(c(4L, 5L, 8L, 3L)) # 4
 class(c(4L, 5L, 8L, 3L)) # "integer"
 
 # LES NUMÉRIQUES
-# Un "numeric" est un nombre à virgule flottante avec une double précision
+# Un "numeric" est un nombre à virgule flottante d'une précision double
 5 # 5
 class(5) # "numeric"
 # Encore une fois, tout dans R est un vecteur ;
 # Vous pouvez faire un vecteur numérique avec plus d'un élément
 c(3,3,3,2,2,1) # 3 3 3 2 2 1
-# Vous pouvez utiliser la notation scientifique aussi
+# Vous pouvez aussi utiliser la notation scientifique
 5e4 # 50000
 6.02e23 # nombre d'Avogadro
 1.6e-35 # longueur de Planck
@@ -198,24 +195,25 @@ class(-Inf)	# "numeric"
 
 # ARITHMÉTIQUES DE BASE
 # Vous pouvez faire de l'arithmétique avec des nombres
-# Faire des opérations arithmétiques en mixant des entiers et des numériques
+# Faire des opérations arithmétiques en mixant des entiers
+# et des numériques
 # donne un autre numérique
 10L + 66L # 76      # un entier plus un entier donne un entier
 53.2 - 4  # 49.2    # un numérique moins un numérique donne un numérique
 2.0 * 2L  # 4       # un numérique multiplié par un entier donne un numérique
 3L / 4    # 0.75    # un entier sur un numérique donne un numérique
-3 %% 2	  # 1       # le reste de deux numériques est un autre numérique
-# Les opérations arithmétiques illégales rapportent un "Not A Number" :
+3 %% 2    # 1       # le reste de deux numériques est un autre numérique
+# Les opérations arithmétiques illégales donnent un "Not A Number" :
 0 / 0 # NaN
 class(NaN) # "numeric"
-# You can do arithmetic on two vectors with length greater than 1,
 # Vous pouvez faire des opérations arithmétiques avec deux vecteurs d'une
 # longueur plus grande que 1, à condition que la longueur du plus grand
 # vecteur soit un multiple entier du plus petit
 c(1,2,3) + c(1,2,3) # 2 4 6
 
 # LES CARACTÈRES
-# Il n'y a pas de différences entre les chaînes de caractères et les caractères en R
+# Il n'y a pas de différences entre les chaînes de caractères et
+# les caractères en R
 "Horatio" # "Horatio"
 class("Horatio") # "character"
 class('H') # "character"
@@ -225,7 +223,7 @@ c('alef', 'bet', 'gimmel', 'dalet', 'he')
 # =>
 # "alef"   "bet"    "gimmel" "dalet"  "he"
 length(c("Call","me","Ishmael")) # 3
-# Vous pouvez faire des expressions rationnelles sur les vecteurs de caractères :
+# Vous pouvez utiliser des expressions rationnelles sur les vecteurs de caractères :
 substr("Fortuna multis dat nimis, nulli satis.", 9, 15) # "multis "
 gsub('u', 'ø', "Fortuna multis dat nimis, nulli satis.") # "Fortøna møltis dat nimis, nølli satis."
 # R possède plusieurs vecteurs de caractères préconstruits :
@@ -246,45 +244,57 @@ FALSE != FALSE	# FALSE
 FALSE != TRUE	# TRUE
 # Les données manquantes (NA) sont logiques également
 class(NA)	# "logical"
+# On utilise | et & pour les operations logiques.
+# OR
+TRUE | FALSE	# TRUE
+# AND
+TRUE & FALSE	# FALSE
+# Vous pouvez tester si x est TRUE
+isTRUE(TRUE)	# TRUE
 # Ici nous avons un vecteur de type logique avec plusieurs éléments :
 c('Z', 'o', 'r', 'r', 'o') == "Zorro" # FALSE FALSE FALSE FALSE FALSE
 c('Z', 'o', 'r', 'r', 'o') == "Z" # TRUE FALSE FALSE FALSE FALSE
 
 # LES FACTEURS
-# The factor class is for categorical data
-# La classe facteur sert aux données catégorielles
-# les facteurs peuvent être ordonnés (comme les niveaux de catégorie d'enfants)
+# La classe facteur sert pour les données catégorielles
+# les facteurs peuvent être ordonnés (comme les niveaux de
+# catégorie d'enfants)
 # ou non ordonnés (comme le sexe)
 factor(c("female", "female", "male", NA, "female"))
 #  female female male   <NA>   female
 # Les niveaux : female male
-# Les "levels" sont les valeurs que les données catégorielles peuvent prendre
-# Notez que cette donnée manquante n'entre pas dans le niveau
+# Les "levels" sont les valeurs que les données catégorielles
+# peuvent prendre
+# Notez que les données manquantes n'entrent pas dans le niveau
 levels(factor(c("male", "male", "female", NA, "female"))) # "female" "male"
-# Si le vecteur de facteurs a une longueur 1, ses niveaux seront de longueur 1 également
+# Si le vecteur de facteurs a une longueur 1, ses niveaux seront
+# de longueur 1 également
 length(factor("male")) # 1
 length(levels(factor("male"))) # 1
-# On rencontre communément des facteurs dans des trames de données, 
-# une structure de données que nous couvrirons plus tard
+# On rencontre communément des facteurs dans des "data frame",
+# un type de données que nous couvrirons plus tard
 data(infert) # "Infertility after Spontaneous and Induced Abortion"
 levels(infert$education) # "0-5yrs"  "6-11yrs" "12+ yrs"
 
 # NULL
 # "NULL" est bizarre ; on l'utilise pour effacer un vecteur
 class(NULL)	# NULL
+parakeet = c("beak", "feathers", "wings", "eyes")
 parakeet
 # =>
-# [1] "beak"     "feathers" "wings"    "eyes"    
+# [1] "beak"     "feathers" "wings"    "eyes"
 parakeet <- NULL
 parakeet
 # =>
 # NULL
 
 # LES CONTRAINTES DE TYPES
-# Les contraintes de types servent à forcer une valeur à prendre un type différent
+# Les contraintes de types servent à forcer une valeur à prendre
+# un type différent
 as.character(c(6, 8)) # "6" "8"
 as.logical(c(1,0,1,1)) # TRUE FALSE  TRUE  TRUE
-# Si vous mettez des éléments de différents types dans un vecteur, des coercitions bizarres se produisent :
+# Si vous mettez des éléments de différents types dans un vecteur,
+# des coercitions bizarres se produisent :
 c(TRUE, 4) # 1 4
 c("dog", TRUE, 4) # "dog"  "TRUE" "4"
 as.numeric("Bilbo")
@@ -294,17 +304,19 @@ as.numeric("Bilbo")
 # NAs est introduit par coercition
 
 # Notez également : ce n'étaient que des types de données basiques
-# Il y a beaucoup d'autres types de données, comme pour les dates, les séries de temps, etc ...
+# Il y a beaucoup d'autres types de données, comme pour les dates,
+# les séries temporelles, etc ...
 
 
 
-##################################################
+#######################################
 # Variables, boucles , if/else
-##################################################
+#######################################
 
-# Une variable est comme une boîte où l'on garde une valeur pour l'utiliser plus tard.
+# Une variable est comme une boîte dans laquelle on garde une valeur
+# pour l'utiliser plus tard.
 # Nous appellons ça "assigner" une valeur à une variable.
-# Avoir des variables nous permets d'écrire des boucles, des fonctions, et
+# Avoir des variables nous permet d'écrire des boucles, des fonctions, et
 # des instructions conditionnelles (if/else)
 
 # LES VARIABLES
@@ -321,19 +333,22 @@ for (i in 1:4) {
 # Il y a les boucles while :
 a <- 10
 while (a > 4) {
-	cat(a, "...", sep = "")
-	a <- a - 1
+    cat(a, "...", sep = "")
+    a <- a - 1
 }
-# Gardez à l'esprit que les boucles for et while s'exécute lentement en R
-# Des opérations sur des vecteurs entiers (ex un ligne entière, une colonne entière),
-# ou la fonction apply()-type (nous en parlerons plus tard), sont préférés
+# Gardez à l'esprit que les boucles for et while s'exécutent lentement
+# en R
+# Des opérations sur des vecteurs entiers (ex une ligne entière,
+# une colonne entière),
+# ou les fonctions de type apply() (nous en parlerons plus tard),
+# sont préférées
 
 # IF/ELSE
 # Encore une fois assez standard
 if (4 > 3) {
-	print("4 is greater than 3")
+    print("4 is greater than 3")
 } else {
-	print("4 is not greater than 3")
+    print("4 is not greater than 3")
 }
 # =>
 # [1] "4 is greater than 3"
@@ -341,25 +356,27 @@ if (4 > 3) {
 # LES FONCTIONS
 # se définissent comme ceci :
 jiggle <- function(x) {
-	x = x + rnorm(1, sd=.1)	#add in a bit of (controlled) noise
-	return(x)
+    x = x + rnorm(1, sd=.1)	#add in a bit of (controlled) noise
+    return(x)
 }
-# Appelée comme n'importe quelle autre fonction R :
+# Appelées comme n'importe quelles autres fonction R :
 jiggle(5)	# 5±ε. After set.seed(2716057), jiggle(5)==5.005043
 
 
 
-###########################################################################
-# Les structures de données : les vecteurs, les matrices, les trames de données et les tableaux
-###########################################################################
+##########################################################################
+# Les structures de données : les vecteurs, les matrices,
+# les data frame et les tableaux
+##########################################################################
 
 # À UNE DIMENSION
 
-# Commençons par le tout début, et avec quelque chose que vous connaissez déjà : les vecteurs.
+# Commençons par le tout début, et avec quelque chose que
+# vous connaissez déjà : les vecteurs.
 vec <- c(8, 9, 10, 11)
 vec	#  8  9 10 11
 # Nous demandons des éléments spécifiques en les mettant entre crochets
-# (Notez que R commence à compter par 1)
+# (Notez que R commence à compter à partir de 1)
 vec[1]		# 8
 letters[18]	# "r"
 LETTERS[13]	# "M"
@@ -367,7 +384,7 @@ month.name[9]	# "September"
 c(6, 8, 7, 5, 3, 0, 9)[3]	# 7
 # Nous pouvons également rechercher des indices de composants spécifiques,
 which(vec %% 2 == 0)	# 1 3
-# Récupèrer seulement quelques premières ou dernières entrées du vecteur,
+# Récupèrer seulement les premières ou dernières entrées du vecteur,
 head(vec, 1)	# 8
 tail(vec, 2)	# 10 11
 # ou trouver si un certaine valeur est dans le vecteur
@@ -376,7 +393,8 @@ any(vec == 10) # TRUE
 vec[6]	# NA
 # Vous pouvez trouver la longueur de votre vecteur avec length()
 length(vec)	# 4
-# Vous pouvez réaliser des opérations sur des vecteurs entiers ou des sous-ensembles de vecteurs
+# Vous pouvez réaliser des opérations sur des vecteurs entiers ou des
+# sous-ensembles de vecteurs
 vec * 4	# 16 20 24 28
 vec[2:3] * 5	# 25 30
 any(vec[2:3] == 8) # FALSE
@@ -396,7 +414,7 @@ seq(from=0, to=31337, by=1337)
 
 # À DEUX DIMENSIONS (TOUT DANS UNE CLASSE)
 
-# Vous pouvez faire une matrice de toutes les entrées du même type comme ceci :
+# Vous pouvez créer une matrice à partir d'entrées du même type comme ceci :
 mat <- matrix(nrow = 3, ncol = 2, c(1,2,3,4,5,6))
 mat
 # =>
@@ -404,13 +422,14 @@ mat
 # [1,]    1    4
 # [2,]    2    5
 # [3,]    3    6
-# Différemment du vecteur, la classe d'une matrice est "matrix",peut importe ce qu'elle contient
+# Différemment du vecteur, la classe d'une matrice est "matrix",
+# peut importe ce qu'elle contient
 class(mat) # => "matrix"
 # Demander la première ligne
 mat[1,]	# 1 4
 # Réaliser une opération sur la première colonne
 3 * mat[,1]	# 3 6 9
-# Ask for a specific cell
+# Demander une cellule spécifique
 mat[3,2]	# 6
 
 # Transposer la matrice entière
@@ -432,15 +451,15 @@ mat %*% t(mat)
 mat2 <- cbind(1:4, c("dog", "cat", "bird", "dog"))
 mat2
 # =>
-#      [,1] [,2]   
-# [1,] "1"  "dog"  
-# [2,] "2"  "cat"  
-# [3,] "3"  "bird" 
+#      [,1] [,2]
+# [1,] "1"  "dog"
+# [2,] "2"  "cat"
+# [3,] "3"  "bird"
 # [4,] "4"  "dog"
 class(mat2)	# matrix
-# Encore une fois notez ce qui se passe !
-# Parce que les matrices peuvent contenir des entrées de toutes sortes de classes,
-# tout sera converti en classe caractère
+# Encore une fois regardez ce qui se passe !
+# Parce que les matrices peuvent contenir des entrées de toutes sortes de
+# classes, tout sera converti en classe caractère
 c(class(mat2[,1]), class(mat2[,2]))
 
 # rbind() colle des vecteurs ensemble par lignes pour faire une matrice
@@ -454,7 +473,7 @@ mat3
 
 # À DEUX DIMENSIONS (DE CLASSES DIFFÉRENTES)
 
-# Pour des colonnes de différents types, utiliser une trame de donnée
+# Pour des colonnes de différents types, utiliser une data frame
 # Cette structure de données est si utile pour la programmation statistique,
 # qu'une version a été ajoutée à Python dans le paquet "pandas".
 
@@ -478,25 +497,25 @@ class(students[,3])	# "factor"
 nrow(students)	# 6
 ncol(students)	# 3
 dim(students)	# 6 3
-# La fonction data.frame() convertit les vecteurs caractères en vecteurs de facteurs
-# par défaut; désactiver cette fonction en règlant stringsAsFactors = FALSE
-# quand vous créer la data.frame
+# La fonction data.frame() convertit les vecteurs caractères en vecteurs de
+# facteurs par défaut; désactiver cette fonction en règlant
+# stringsAsFactors = FALSE quand vous créer la data.frame
 ?data.frame
 
-# Il y a plusieurs façons tortueuses de subdiviser les trames de données
+# Il y a plusieurs façons de subdiviser les trames de données
 # toutes subtilement différentes
 students$year	# 3  2  2  1  0 -1
 students[,2]	# 3  2  2  1  0 -1
 students[,"year"]	# 3  2  2  1  0 -1
 
 # Une version augmentée de la structure data.frame est data.table
-# Si vous travaillez avec des données volumineuses ou des panels, ou avez 
+# Si vous travaillez avec des données volumineuses ou des panels, ou avez
 # besoin de fusionner quelques ensembles de données, data.table peut être
 # un bon choix. Ici un tour éclair :
-install.packages("data.table") # download the package from CRAN
-require(data.table) # load it
+install.packages("data.table") # télécharge le paquet depuis CRAN
+require(data.table) # le charge
 students <- as.data.table(students)
-students # note the slightly different print-out
+students # regardez la différence à l'impression
 # =>
 #      name year house
 # 1: Cedric    3     H
@@ -505,17 +524,17 @@ students # note the slightly different print-out
 # 4:    Cho    1     R
 # 5:  Draco    0     S
 # 6:  Ginny   -1     G
-students[name=="Ginny"] # get rows with name == "Ginny"
+students[name=="Ginny"] # obtiens les lignes avec name == "Ginny"
 # =>
 #     name year house
 # 1: Ginny   -1     G
-students[year==2] # get rows with year == 2
+students[year==2] # obtiens les lignes avec year == 2
 # =>
 #      name year house
 # 1:   Fred    2     G
 # 2: George    2     G
 # data.table facilite la fusion entre deux ensembles de données
-# Faisons un autre data.table pour fusionner students
+# Faisons une autre data.table pour fusionner students
 founders <- data.table(house=c("G","H","R","S"),
                        founder=c("Godric","Helga","Rowena","Salazar"))
 founders
@@ -527,7 +546,7 @@ founders
 # 4:     S Salazar
 setkey(students, house)
 setkey(founders, house)
-students <- founders[students] # merge the two data sets by matching "house"
+students <- founders[students] # merge les deux ensembles de données qui matchent "house"
 setnames(students, c("house","houseFounderName","studentName","year"))
 students[,order(c("name","year","house","houseFounderName")), with=F]
 # =>
@@ -539,7 +558,7 @@ students[,order(c("name","year","house","houseFounderName")), with=F]
 # 5:         Cho    1     R           Rowena
 # 6:       Draco    0     S          Salazar
 
-# data.table facilite le sommaire des tableaux
+# data.table facilite le résumé des tableaux
 students[,sum(year),by=house]
 # =>
 #    house V1
@@ -561,7 +580,7 @@ students
 # 5:         Cho    1     R
 # 6:       Draco    0     S
 
-# Supprimer une ligne en subdivisant 
+# Supprimer une ligne en subdivisant
 # En utilisant data.table :
 students[studentName != "Draco"]
 # =>
@@ -607,16 +626,17 @@ array(c(c(c(2,300,4),c(8,9,0)),c(c(5,60,0),c(66,7,847))), dim=c(3,2,2))
 # [2,]   60    7
 # [3,]    0  847
 
-# LES LISTES (MULTI-DIMENSIONNELLES, ÉVENTUELLEMMENT DÉCHIRÉES, DE DIFFÉRENTS TYPES)
+# LES LISTES (MULTI-DIMENSIONNELLES, ÉVENTUELLEMMENT DÉCHIRÉES,
+# DE DIFFÉRENTS TYPES)
 
 # Enfin R a des listes (de vecteurs)
 list1 <- list(time = 1:40)
 list1$price = c(rnorm(40,.5*list1$time,4)) # random
 list1
 # Vous pouvez obtenir des éléments de la liste comme ceci
-list1$time # one way
-list1[["time"]] # another way
-list1[[1]] # yet another way
+list1$time # une façon
+list1[["time"]] # une autre façon
+list1[[1]] # encore une façon différente
 # =>
 #  [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
 # [34] 34 35 36 37 38 39 40
@@ -624,13 +644,14 @@ list1[[1]] # yet another way
 list1$price[4]
 
 # Les listes ne sont pas les structures de données les plus efficaces
-# pour travailler en R;
-# À moins d'avoir une très bonne raison, vous devriez appliquer data.frames
-# Les listes sont souvent retournées par des fonctions qui effectuent des régressions linéaires
+# à utiliser avec R;
+# À moins d'avoir une très bonne raison, vous devriez utiliser data.frames
+# Les listes sont souvent retournées par des fonctions qui effectuent
+# des régressions linéaires
 
-##################################################
+##########################################
 # La famille de fonction apply()
-##################################################
+##########################################
 
 # Vous vous rappelez mat ?
 mat
@@ -641,8 +662,8 @@ mat
 # [3,]    3    6
 # Utilisez apply(X, MARGIN, FUN) pour appliquer la fonction FUN à la matrice X
 # sur les lignes (MAR = 1) ou les colonnes (MAR = 2)
-# R fait FUN à chaque lignes (ou colonnes) de X, beaucoup plus rapidement
-# qu'une bouce for ou while le ferait
+# R exécute FUN à chaque lignes (ou colonnes) de X, beaucoup plus rapidement
+# que le ferait une boucle for ou while
 apply(mat, MAR = 2, jiggle)
 # =>
 #      [,1] [,2]
@@ -650,7 +671,7 @@ apply(mat, MAR = 2, jiggle)
 # [2,]    7   19
 # [3,]   11   23
 # D'autres fonctions : ?lapply, ?sapply
- 
+
 # Ne soyez pas trop intimidé ; tout le monde reconnaît que c'est un peu déroutant
 
 # Le paque plyr vise à remplacer (et améliorer !) la famille *apply().
@@ -660,9 +681,9 @@ require(plyr)
 
 
 
-#########################
+############################
 # Charger des données
-#########################
+############################
 
 # "pets.csv" est un fichier sur internet
 # (mais il pourrait être tout aussi facilement sur votre ordinateur)
@@ -671,7 +692,7 @@ pets
 head(pets, 2) # first two rows
 tail(pets, 1) # last row
 
-# Pour sauver une trame de donnée ou une matrice en fichier .csv
+# Pour sauvegarder une data frame ou une matrice en fichier .csv
 write.csv(pets, "pets2.csv") # to make a new .csv file
 # définir le répertoire de travail avec setwd(), le récupérer avec getwd()
 
@@ -679,9 +700,9 @@ write.csv(pets, "pets2.csv") # to make a new .csv file
 
 
 
-#########################
+################
 # Les tracés
-#########################
+################
 
 # LES FONCTIONS DE TRACÉS PRÉCONSTRUITES
 # Les diagrammes de dispersion !
@@ -700,7 +721,7 @@ barplot(c(1,4,5,1,2), names.arg = c("red","blue","purple","green","yellow"))
 
 # GGPLOT2
 # Mais ceux-ci ne sont même pas les plus jolis tracés de R
-# Essayez le paquet ggplot2 pour d'avantages de graphiques meilleurs
+# Essayez le paquet ggplot2 pour d'avantages de graphiques
 install.packages("ggplot2")
 require(ggplot2)
 ?ggplot2
@@ -709,13 +730,14 @@ pp + geom_histogram()
 ll <- as.data.table(list1)
 pp <- ggplot(ll, aes(x=time,price))
 pp + geom_point()
-# ggplot2 a une documentation excellente (disponible sur http://docs.ggplot2.org/current/)
+# ggplot2 a une documentation excellente
+#(disponible sur http://docs.ggplot2.org/current/)
 
 
 
 ```
 
-## How do I get R?
+## Comment j'obtiens R ?
 
-* Get R and the R GUI from [http://www.r-project.org/](http://www.r-project.org/)
-* [RStudio](http://www.rstudio.com/ide/) is another GUI
+* Obtiens R et R GUI depuis [http://www.r-project.org/](http://www.r-project.org/)
+* [RStudio](http://www.rstudio.com/ide/) est un autre GUI