From c5723d5e2a6302b3047569aa94c7974cad868287 Mon Sep 17 00:00:00 2001 From: Adam Bard Date: Fri, 5 Dec 2014 22:45:17 +0100 Subject: Fixes #882 --- fr-fr/brainfuck-fr.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'fr-fr') diff --git a/fr-fr/brainfuck-fr.html.markdown b/fr-fr/brainfuck-fr.html.markdown index 3882734d..545e407e 100644 --- a/fr-fr/brainfuck-fr.html.markdown +++ b/fr-fr/brainfuck-fr.html.markdown @@ -13,7 +13,7 @@ Brainfuck (sans majuscule à part au début d’une phrase) est un langage Turing-complet extrêmement simple avec seulement 8 commandes. ``` -Tout caractère en dehors de "><+-.,[]" (en dehors des guillements) est ignoré. +Tout caractère en dehors de "><+-.,[]" (en dehors des guillemets) est ignoré. Brainfuck est représenté par un tableau de 30 000 cellules initialisées à 0 et un pointeur de données pointant sur la cellule courante. -- cgit v1.2.3 From 22d0cb02a8e08532555edde1f5ccf9a34a2b6a77 Mon Sep 17 00:00:00 2001 From: Fla Date: Mon, 12 Jan 2015 14:10:41 +0100 Subject: Typo --- fr-fr/ruby-fr.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'fr-fr') diff --git a/fr-fr/ruby-fr.html.markdown b/fr-fr/ruby-fr.html.markdown index 75c8d0d3..1564d2b6 100644 --- a/fr-fr/ruby-fr.html.markdown +++ b/fr-fr/ruby-fr.html.markdown @@ -268,7 +268,7 @@ end # implicitement la valeur de la dernière instruction évaluée double(2) #=> 4 -# Les paranthèses sont facultative +# Les parenthèses sont facultatives # lorsqu'il n'y a pas d'ambiguïté sur le résultat double 3 #=> 6 -- cgit v1.2.3 From abce4e0a2fd8598a2768bcef86623a02e5f572e5 Mon Sep 17 00:00:00 2001 From: Jean-Philippe Monette Date: Tue, 17 Mar 2015 20:25:44 +0000 Subject: Adding Go French translation --- fr-fr/go-fr.html.markdown | 430 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 430 insertions(+) create mode 100644 fr-fr/go-fr.html.markdown (limited to 'fr-fr') diff --git a/fr-fr/go-fr.html.markdown b/fr-fr/go-fr.html.markdown new file mode 100644 index 00000000..1d2b656b --- /dev/null +++ b/fr-fr/go-fr.html.markdown @@ -0,0 +1,430 @@ +--- +name: Go +category: language +language: Go +filename: learngo.go +contributors: + - ["Sonia Keys", "https://github.com/soniakeys"] + - ["Christopher Bess", "https://github.com/cbess"] + - ["Jesse Johnson", "https://github.com/holocronweaver"] + - ["Quint Guvernator", "https://github.com/qguv"] + - ["Jose Donizetti", "https://github.com/josedonizetti"] + - ["Alexej Friesen", "https://github.com/heyalexej"] + - ["Jean-Philippe Monette", "http://blogue.jpmonette.net/"] +--- + +Go a été créé dans l'optique de déveloper de façcon efficace. Ce n'est pas la +dernière tendance en ce qui au développement, mais c'est la nouvelle façon de +régler des défis réels de façcon rapide. + +Le langage possède des concepts familiers à la programmation impérative avec +typage. Il est rapide à compiler et exécuter, ajoute une concurrence facile à +comprendre pour les processeurs multi coeurs d'aujourd'hui et apporte des +fonctionnalités facilitant le développement à grande échelle. + +Développer avec Go, c'est bénéficier d'une riche librairie standard et d'une +communauté active. + +```go +// Commentaire ligne simple +/* Commentaire + multiligne */ + +// Un paquet débute avec une clause "package" +// "Main" est un nom spécial déclarant un paquet de type exécutable plutôt +// qu'une librairie +package main + +// "Import" déclare les paquets référencés dans ce fichier. +import ( + "fmt" // Un paquet dans la librairie standard. + "io/ioutil" // Implémente des fonctions utilitaires I/O. + m "math" // Librairie mathématique utilisant un alias local "m". + "net/http" // Un serveur Web! + "strconv" // Librairie pour convertir les chaînes de caractères. +) + +// Une définition de fonction. La fonction "main" est spéciale - c'est le point +// d'entrée du binaire. Celle-ci est encapsulée par des accolades. +func main() { + // Println retourne une ligne à stdout. + // Associez la fonction avec son paquet respectif, fmt. + fmt.Println("Hello world!") + + // Appelez une fonction différente à partir de ce paquet. + beyondHello() +} + +// Les fonctions ont des paramètres entre parenthèses. +// Les parenthèses sont nécessaires avec ou sans paramètre. +func beyondHello() { + var x int // Déclaration de variable. Les variables doivent être déclarées + // avant leur utilisation. + x = 3 // Assignation de valeur. + // Les déclarations courtes utilisent := pour inférer le type, déclarer et + // assigner. + y := 4 + sum, prod := learnMultiple(x, y) // La fonction retourne deux valeurs. + fmt.Println("sum:", sum, "prod:", prod) // Affichage simple. + learnTypes() // < y minutes, en savoir plus! +} + +// Les fonctions peuvent avoir des paramètres et plusieurs valeurs retournées. +func learnMultiple(x, y int) (sum, prod int) { + return x + y, x * y // Deux valeurs retournées. +} + +// Quelques types inclus et littéraux. +func learnTypes() { + // Déclaration courte produit généralement le type désiré. + str := "Learn Go!" // Type string. + + s2 := `Une chaîne de caractères peut contenir des +sauts de ligne.` // Chaîne de caractère. + + // Littéral non-ASCII. Les sources Go utilisent le charset UTF-8. + g := 'Σ' // type rune, un alias pour le type int32, contenant un caractère + // unicode. + + f := 3.14195 // float64, un nombre flottant IEEE-754 de 64-bit. + c := 3 + 4i // complex128, représenté à l'interne par deux float64. + + // Syntaxe "var" avec une valeur d'initialisation. + var u uint = 7 // Non signé, mais la taille dépend selon l'entier. + var pi float32 = 22. / 7 + + // Conversion avec syntaxe courte. + n := byte('\n') // byte est un alias du type uint8. + + // Les tableaux ont des tailles fixes à la compilation. + var a4 [4]int // Un tableau de 4 ints, tous initialisés à 0. + a3 := [...]int{3, 1, 5} // Un tableau initialisé avec une taille fixe de 3 + // éléments, contenant les valeurs 3, 1 et 5. + + // Les slices ont des tailles dynamiques. Les tableaux et slices ont chacun + // des avantages, mais les usages des slices sont plus communs. + s3 := []int{4, 5, 9} // Comparable à a3. + s4 := make([]int, 4) // Alloue un slice de 4 ints, initialisés à 0. + var d2 [][]float64 // Déclaration seulement, sans allocation de mémoire. + bs := []byte("a slice") // Conversion d'une chaîne en slice de bytes. + + // Parce qu'elles sont dynamiques, les slices peuvent être jointes sur + // demande. Pour joindre un élément à une slice, la fonction standard append() + // est utilisée. Le premier argument est la slice à utiliser. Habituellement, + // la variable tableau est mise à jour sur place, voir ci-bas. + s := []int{1, 2, 3} // Le résultat est une slice de taille 3. + s = append(s, 4, 5, 6) // Ajout de 3 valeurs. La taille est de 6. + fmt.Println(s) // La valeur est maintenant de [1 2 3 4 5 6] + // Pour ajouter une autre slice, au lieu d'utiliser une liste de valeurs + // atomiques, il est possible de mettre en argument une référence de + // slice littérale de cette façon, avec des points de suspension, signifiant + // qu'il faut prendre les éléments de la slice et les ajouter à la slice s. + s = append(s, []int{7, 8, 9}...) // Le deuxième argument est une slice + // littérale. + fmt.Println(s) // La slice contient [1 2 3 4 5 6 7 8 9] + + p, q := learnMemory() // Déclare p, q comme étant des pointeurs de type int. + fmt.Println(*p, *q) // * suit un pointeur. Ceci retourne deux ints. + + // Les maps sont des tableaux associatifs de taille dynamique, comme les + // hash ou les types dictionnaires de certains langages. + m := map[string]int{"trois": 3, "quatre": 4} + m["un"] = 1 + + // Les valeurs inutilisées sont des erreurs en Go. + // Un tiret bas permet d'utiliser une variable, mais d'en jeter la valeur. + _, _, _, _, _, _, _, _, _, _ = str, s2, g, f, u, pi, n, a3, s4, bs + // L'affichage est considéré comme une utilisation de la variable. + fmt.Println(s, c, a4, s3, d2, m) + + learnFlowControl() // De retour dans le flux. +} + +// Il est possible, à l'opposée de plusieurs autres langages, à des fonctions +// en go d'avoir des valeurs retournées avec nom. +// Assigner un nom à un type retourné par une fonction permet de retrouver sa +// valeur ainsi que d'utiliser le mot-clé "return" uniquement, sans plus. +func learnNamedReturns(x, y int) (z int) { + z = x * y + return // z est implicite, car la variable a été définie précédemment. +} + +// La récupération de la mémoire est automatique en Go. Le langage possède des +// pointeurs, mais aucun pointeur arithmétique. Vous pouvez faire une erreur +// avec un pointeur nil, mais pas en incrémentant un pointeur. +func learnMemory() (p, q *int) { + // Les valeurs retournées définies p et q ont le type pointeur int. + p = new(int) // Fonction standard "new" alloue la mémoire. + // Le int alloué est initialisé à 0, p n'est plus nil. + s := make([]int, 20) // Alloue 20 ints en un seul bloc de mémoire. + s[3] = 7 // Assigne l'un des entiers. + r := -2 // Déclare une autre variable locale. + return &s[3], &r // & retourne l'adresse d'un objet. +} + +func expensiveComputation() float64 { + return m.Exp(10) +} + +func learnFlowControl() { + // Bien que les "if" requiert des accolades, les parenthèses ne le sont pas. + if true { + fmt.Println("voilà!") + } + // Le formate est standardisé par la commande shell "go fmt." + if false { + // bing. + } else { + // bang. + } + // Utilisez "switch" au lieu des "if" en chaîne + x := 42.0 + switch x { + case 0: + case 1: + case 42: + // Les "case" n'ont pas besoin de "break;". + case 43: + // Non-exécuté. + } + // Comme les "if", "for" n'utilise pas de parenthèses. + // Les variables déclarées dans "for" et "if" sont locales à leur portée. + for x := 0; x < 3; x++ { // ++ est une incrémentation. + fmt.Println("itération ", x) + } + // x == 42 ici. + + // "For" est le seul type de boucle en Go, mais possède différentes formes. + for { // Boucle infinie + break // C'est une farce + continue // Non atteint. + } + + // Vous pouvez utiliser un "range" pour itérer dans un tableau, une slice, une + // chaîne, une map ou un channel. Les "range" retournent un canal ou deux + // valeurs (tableau, slice, chaîne et map). + for key, value := range map[string]int{"une": 1, "deux": 2, "trois": 3} { + // pour chaque pair dans une map, affichage de la valeur et clé + fmt.Printf("clé=%s, valeur=%d\n", key, value) + } + + // À l'opposé du "for", := dans un "if" signifie la déclaration et + // l'assignation y en premier, et ensuite y > x + if y := expensiveComputation(); y > x { + x = y + } + // Les fonctions littérales est une fermeture (closure). + xBig := func() bool { + return x > 10000 // Réfère à la variable x déclarée en haut du "switch". + } + fmt.Println("xBig:", xBig()) // true (la valeur e^10 a été assignée à x). + x = 1.3e3 // Ceci fait x == 1300 + fmt.Println("xBig:", xBig()) // Maintenant false. + + // De plus, les fonctions littérales peuvent être définies et appelée + // sur la même ligne, agissant comme argument de fonctions, tant que: + // a) la fonction littérale est appelée suite à (), + // b) le résultat correspond au type de l'argument. + fmt.Println("Ajoute + multiplie deux nombres: ", + func(a, b int) int { + return (a + b) * 2 + }(10, 2)) // Appelé avec les arguments 10 et 2 + // => Ajoute + double deux nombres: 24 + + // Quand vous en aurez besoin, vous allez l'adorer. + goto love +love: + + learnFunctionFactory() // func retournant func correspond à fun(3)(3). + learnDefer() // Un survol de cette instruction important. + learnInterfaces() // Incontournable! +} + +func learnFunctionFactory() { + // Les deux syntaxes sont identiques, bien que la seconde est plus pratique. + fmt.Println(sentenceFactory("été")("Une matinée d'", "agréable!")) + + d := sentenceFactory("été") + fmt.Println(d("Une matinée d'", "agréable!")) + fmt.Println(d("Une soirée d'", "relaxante!")) +} + +// Le décorateur est un patron de conception commun dans d'autres langages. +// Il est possible de faire de même en Go avec des fonctions littérales +// acceptant des arguments. +func sentenceFactory(mystring string) func(before, after string) string { + return func(before, after string) string { + return fmt.Sprintf("%s %s %s", before, mystring, after) // nouvelle chaîne + } +} + +func learnDefer() (ok bool) { + // Les déclarations différées sont exécutées avant la sortie d'une fonction. + defer fmt.Println("les déclarations différées s'exécutent en ordre LIFO.") + defer fmt.Println("\nCette ligne est affichée en premier parce que") + // Les déclarations différées sont utilisées fréquemment pour fermer un + // fichier, afin que la fonction ferme le fichier en fin d'exécution. + return true +} + +// Défini Stringer comme étant une interface avec une méthode, String. +type Stringer interface { + String() string +} + +// Défini pair comme étant une structure contenant deux entiers, x et y. +type pair struct { + x, y int +} + +// Défini une méthode associée au type pair. Pair implémente maintenant Stringer +func (p pair) String() string { // p s'appelle le "destinataire" + // Sprintf est une autre fonction publique dans le paquet fmt. + // La syntaxe avec point permet de faire référence aux valeurs de p. + return fmt.Sprintf("(%d, %d)", p.x, p.y) +} + +func learnInterfaces() { + // La syntaxe avec accolade défini une "structure littérale". Ceci s'évalue + // comme étant une strucutre. La syntaxe := déclare et initialise p comme + // étant cette structure. + p := pair{3, 4} + fmt.Println(p.String()) // Appelle la méthode String de p, de type pair. + var i Stringer // Déclare i de l'interface de type Stringer. + i = p // Valide, car pair implémente Stringer. + // Appelle la méthode String de i, de type Stringer. Retourne la même valeur + // que ci-haut. + fmt.Println(i.String()) + + // Les fonctions dans le paquet fmt appellent la méthode String, demandant + // aux objets d'afficher une représentation de leur structure. + fmt.Println(p) // Affiche la même chose que ci-haut. Println appelle la + // méthode String. + fmt.Println(i) // Affiche la même chose que ci-haut. + + learnVariadicParams("apprentissage", "génial", "ici!") +} + +// Les fonctions peuvent avoir des paramètres variables. +func learnVariadicParams(myStrings ...interface{}) { + // Itère chaque valeur du paramètre variable. + // Le tiret bas sert à ignorer l'index retourné du tableau. + for _, param := range myStrings { + fmt.Println("paramètre:", param) + } + + // Passe une valeur variadique comme paramètre variadique. + fmt.Println("paramètres:", fmt.Sprintln(myStrings...)) + + learnErrorHandling() +} + +func learnErrorHandling() { + // ", ok" expression utilisée pour définir si quelque chose a fonctionné ou + // non. + m := map[int]string{3: "trois", 4: "quatre"} + if x, ok := m[1]; !ok { // ok sera faux, car 1 n'est pas dans la map. + fmt.Println("inexistant") + } else { + fmt.Print(x) // x serait la valeur, si elle se trouvait dans la map. + } + // Une erreur ne retourne qu'un "ok", mais également plus d'information + // par rapport à un problème survenu. + if _, err := strconv.Atoi("non-int"); err != nil { // _ discarte la valeur + // retourne: 'strconv.ParseInt: parsing "non-int": invalid syntax' + fmt.Println(err) + } + // Nous réviserons les interfaces un peu plus tard. Maintenant, + learnConcurrency() +} + +// c est un canal, un objet permettant de communiquer en simultané de façon +// sécuritaire. +func inc(i int, c chan int) { + c <- i + 1 // <- est l'opérateur "destination" quand un canal apparaît à + // gauche. +} + +// Nous utiliserons inc pour incrémenter des nombres en même temps. +func learnConcurrency() { + // La fonction "make" utilisée précédemment pour générer un slice. Elle + // alloue et initialise les slices, maps et les canaux. + c := make(chan int) + // Démarrage de trois goroutines simultanées. Les nombres seront incrémentés + // simultanément, peut-être en paralèle si la machine le permet et configurée + // correctement. Les trois utilisent le même canal. + go inc(0, c) // go est une déclaration démarrant une nouvelle goroutine. + go inc(10, c) + go inc(-805, c) + // Lis et affiche trois résultats du canal - impossible de savoir dans quel + // ordre! + fmt.Println(<-c, <-c, <-c) // Canal à droite, <- est l'opérateur de + // "réception". + + cs := make(chan string) // Un autre canal, celui-ci gère des chaînes. + ccs := make(chan chan string) // Un canal de canaux de chaînes. + go func() { c <- 84 }() // Démarre une nouvelle goroutine, pour + // envoyer une valeur. + go func() { cs <- "wordy" }() // De nouveau, pour cs cette fois-ci. + // Select possède une syntaxe similaire au switch, mais chaque cas requiert + // une opération impliquant un canal. Il sélectionne un cas aléatoirement + // prêt à communiquer. + select { + case i := <-c: // La valeur reçue peut être assignée à une variable, + fmt.Printf("c'est un %T", i) + case <-cs: // ou la valeur reçue peut être discartée. + fmt.Println("c'est une chaîne") + case <-ccs: // Un canal vide, indisponible à la communication. + fmt.Println("ne surviendra pas.") + } + // À ce point, une valeur a été prise de c ou cs. L'une des deux goroutines + // démarrée plus haut a complété, la seconde restera bloquée. + + learnWebProgramming() // Go permet la programmation Web. +} + +// Une seule fonction du paquet http démarre un serveur Web. +func learnWebProgramming() { + + // Le premier paramètre de ListenAndServe is une adresse TCP à écouter. + // Le second est une interface, de type http.Handler. + go func() { + err := http.ListenAndServe(":8080", pair{}) + fmt.Println(err) // n'ignorez pas les erreurs! + }() + + requestServer() +} + +// Fait de pair un http.Handler en implémentant sa seule méthode: ServeHTTP. +func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) { + // Répondez à une requête à l'aide de la méthode http.ResponseWriter. + w.Write([]byte("Vous avez appris Go en Y minutes!")) +} + +func requestServer() { + resp, err := http.Get("http://localhost:8080") + fmt.Println(err) + defer resp.Body.Close() + body, err := ioutil.ReadAll(resp.Body) + fmt.Printf("\nLe serveur Web a dit: `%s`", string(body)) +} +``` + +## En savoir plus + +La référence Go se trouve sur [le site officiel de Go](http://golang.org/). +Vous pourrez y suivre le tutoriel interactif et en apprendre beaucoup plus. + +Une lecture de la documentation du langage est grandement conseillée. C'est +facile à lire et très court (comparé aux autres langages). + +Vous pouvez exécuter modifier le code sur [Go playground](https://play.golang.org/p/tnWMjr16Mm). Essayez de le modifier et de l'exécuter à partir de votre navigateur! Prennez en note que vous pouvez utiliser [https://play.golang.org](https://play.golang.org) comme un [REPL](https://en.wikipedia.org/wiki/Read-eval-print_loop) pour tester et coder dans votre navigateur, sans même avoir à installer Go. + +Sur la liste de lecteur des étudiants de Go se trouve le [code source de la +librairie standard](http://golang.org/src/pkg/). Bien documentée, elle démontre +le meilleur de la clarté de Go, le style ainsi que ses expressions. Sinon, vous +pouvez cliquer sur le nom d'une fonction dans [la +documentation](http://golang.org/pkg/) et le code source apparaît! + +Une autre excellente ressource pour apprendre est [Go par l'exemple](https://gobyexample.com/). -- cgit v1.2.3 From 290c0956d00ddfe23a8cad9ce17f2eaed3a099c0 Mon Sep 17 00:00:00 2001 From: Jean-Philippe Monette Date: Tue, 17 Mar 2015 20:29:01 +0000 Subject: updating translators information --- fr-fr/go-fr.html.markdown | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'fr-fr') diff --git a/fr-fr/go-fr.html.markdown b/fr-fr/go-fr.html.markdown index 1d2b656b..31e1e92b 100644 --- a/fr-fr/go-fr.html.markdown +++ b/fr-fr/go-fr.html.markdown @@ -2,7 +2,7 @@ name: Go category: language language: Go -filename: learngo.go +filename: learngo-fr.go contributors: - ["Sonia Keys", "https://github.com/soniakeys"] - ["Christopher Bess", "https://github.com/cbess"] @@ -10,7 +10,9 @@ contributors: - ["Quint Guvernator", "https://github.com/qguv"] - ["Jose Donizetti", "https://github.com/josedonizetti"] - ["Alexej Friesen", "https://github.com/heyalexej"] +translators: - ["Jean-Philippe Monette", "http://blogue.jpmonette.net/"] +lang: fr-fr --- Go a été créé dans l'optique de déveloper de façcon efficace. Ce n'est pas la -- cgit v1.2.3 From 9922336a9df1359b57695bd5df538d98b8ab2dc0 Mon Sep 17 00:00:00 2001 From: Jean-Philippe Monette Date: Tue, 17 Mar 2015 23:17:50 +0000 Subject: Updating French translation Thanks vendethiel for all the suggestions! --- fr-fr/go-fr.html.markdown | 140 ++++++++++++++++++++++++---------------------- 1 file changed, 73 insertions(+), 67 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/go-fr.html.markdown b/fr-fr/go-fr.html.markdown index 31e1e92b..2ff5902f 100644 --- a/fr-fr/go-fr.html.markdown +++ b/fr-fr/go-fr.html.markdown @@ -2,7 +2,7 @@ name: Go category: language language: Go -filename: learngo-fr.go +filename: learngo.go contributors: - ["Sonia Keys", "https://github.com/soniakeys"] - ["Christopher Bess", "https://github.com/cbess"] @@ -10,21 +10,19 @@ contributors: - ["Quint Guvernator", "https://github.com/qguv"] - ["Jose Donizetti", "https://github.com/josedonizetti"] - ["Alexej Friesen", "https://github.com/heyalexej"] -translators: - ["Jean-Philippe Monette", "http://blogue.jpmonette.net/"] -lang: fr-fr --- -Go a été créé dans l'optique de déveloper de façcon efficace. Ce n'est pas la -dernière tendance en ce qui au développement, mais c'est la nouvelle façon de -régler des défis réels de façcon rapide. +Go a été créé dans l'optique de développer de façon efficace. Ce n'est pas la +dernière tendance en ce qui est au développement, mais c'est la nouvelle façon +de régler des défis réels de façon rapide. Le langage possède des concepts familiers à la programmation impérative avec typage. Il est rapide à compiler et exécuter, ajoute une concurrence facile à -comprendre pour les processeurs multi coeurs d'aujourd'hui et apporte des +comprendre, pour les processeurs multi coeurs d'aujourd'hui et apporte des fonctionnalités facilitant le développement à grande échelle. -Développer avec Go, c'est bénéficier d'une riche librairie standard et d'une +Développer avec Go, c'est bénéficier d'une riche bibliothèque standard et d'une communauté active. ```go @@ -34,22 +32,22 @@ communauté active. // Un paquet débute avec une clause "package" // "Main" est un nom spécial déclarant un paquet de type exécutable plutôt -// qu'une librairie +// qu'une bibliothèque package main // "Import" déclare les paquets référencés dans ce fichier. import ( - "fmt" // Un paquet dans la librairie standard. + "fmt" // Un paquet dans la bibliothèque standard. "io/ioutil" // Implémente des fonctions utilitaires I/O. - m "math" // Librairie mathématique utilisant un alias local "m". + m "math" // Bibliothèque mathématique utilisant un alias local "m". "net/http" // Un serveur Web! - "strconv" // Librairie pour convertir les chaînes de caractères. + "strconv" // Bibliothèque pour convertir les chaînes de caractères. ) // Une définition de fonction. La fonction "main" est spéciale - c'est le point -// d'entrée du binaire. Celle-ci est encapsulée par des accolades. +// d'entrée du binaire. func main() { - // Println retourne une ligne à stdout. + // Println retournera la valeur à la console. // Associez la fonction avec son paquet respectif, fmt. fmt.Println("Hello world!") @@ -78,7 +76,7 @@ func learnMultiple(x, y int) (sum, prod int) { // Quelques types inclus et littéraux. func learnTypes() { - // Déclaration courte produit généralement le type désiré. + // Une déclaration courte infère généralement le type désiré. str := "Learn Go!" // Type string. s2 := `Une chaîne de caractères peut contenir des @@ -89,7 +87,7 @@ sauts de ligne.` // Chaîne de caractère. // unicode. f := 3.14195 // float64, un nombre flottant IEEE-754 de 64-bit. - c := 3 + 4i // complex128, représenté à l'interne par deux float64. + c := 3 + 4i // complex128, considéré comme deux float64 par le compilateur. // Syntaxe "var" avec une valeur d'initialisation. var u uint = 7 // Non signé, mais la taille dépend selon l'entier. @@ -98,13 +96,13 @@ sauts de ligne.` // Chaîne de caractère. // Conversion avec syntaxe courte. n := byte('\n') // byte est un alias du type uint8. - // Les tableaux ont des tailles fixes à la compilation. + // Les tableaux ont une taille fixe déclarée à la compilation. var a4 [4]int // Un tableau de 4 ints, tous initialisés à 0. a3 := [...]int{3, 1, 5} // Un tableau initialisé avec une taille fixe de 3 // éléments, contenant les valeurs 3, 1 et 5. // Les slices ont des tailles dynamiques. Les tableaux et slices ont chacun - // des avantages, mais les usages des slices sont plus communs. + // des avantages, mais les cas d'utilisation des slices sont plus fréquents. s3 := []int{4, 5, 9} // Comparable à a3. s4 := make([]int, 4) // Alloue un slice de 4 ints, initialisés à 0. var d2 [][]float64 // Déclaration seulement, sans allocation de mémoire. @@ -114,13 +112,13 @@ sauts de ligne.` // Chaîne de caractère. // demande. Pour joindre un élément à une slice, la fonction standard append() // est utilisée. Le premier argument est la slice à utiliser. Habituellement, // la variable tableau est mise à jour sur place, voir ci-bas. - s := []int{1, 2, 3} // Le résultat est une slice de taille 3. + s := []int{1, 2, 3} // Le résultat est une slice de taille 3. s = append(s, 4, 5, 6) // Ajout de 3 valeurs. La taille est de 6. - fmt.Println(s) // La valeur est maintenant de [1 2 3 4 5 6] - // Pour ajouter une autre slice, au lieu d'utiliser une liste de valeurs + fmt.Println(s) // La valeur est de [1 2 3 4 5 6] + + // Pour ajouter une slice à une autre, au lieu d'utiliser une liste de valeurs // atomiques, il est possible de mettre en argument une référence de - // slice littérale de cette façon, avec des points de suspension, signifiant - // qu'il faut prendre les éléments de la slice et les ajouter à la slice s. + // slice littérale grâce aux points de suspension. s = append(s, []int{7, 8, 9}...) // Le deuxième argument est une slice // littérale. fmt.Println(s) // La slice contient [1 2 3 4 5 6 7 8 9] @@ -133,17 +131,19 @@ sauts de ligne.` // Chaîne de caractère. m := map[string]int{"trois": 3, "quatre": 4} m["un"] = 1 - // Les valeurs inutilisées sont des erreurs en Go. - // Un tiret bas permet d'utiliser une variable, mais d'en jeter la valeur. + // Les valeurs inutilisées sont considérées comme des erreurs en Go. + // Un tiret bas permet d'ignorer une valeur inutilisée, évitant une erreur. _, _, _, _, _, _, _, _, _, _ = str, s2, g, f, u, pi, n, a3, s4, bs - // L'affichage est considéré comme une utilisation de la variable. + + // Cependant, son affichage en console est considéré comme une utilisation, + // ce qui ne sera pas considéré comme une erreur à la compilation. fmt.Println(s, c, a4, s3, d2, m) learnFlowControl() // De retour dans le flux. } -// Il est possible, à l'opposée de plusieurs autres langages, à des fonctions -// en go d'avoir des valeurs retournées avec nom. +// Il est possible, à l'opposé de plusieurs autres langages, de retourner des +// variables par leur nom à partir de fonctions. // Assigner un nom à un type retourné par une fonction permet de retrouver sa // valeur ainsi que d'utiliser le mot-clé "return" uniquement, sans plus. func learnNamedReturns(x, y int) (z int) { @@ -152,10 +152,11 @@ func learnNamedReturns(x, y int) (z int) { } // La récupération de la mémoire est automatique en Go. Le langage possède des -// pointeurs, mais aucun pointeur arithmétique. Vous pouvez faire une erreur -// avec un pointeur nil, mais pas en incrémentant un pointeur. +// pointeurs, mais aucune arithmétique des pointeurs (*(a + b) en C). Vous +// pouvez produire une erreur avec un pointeur nil, mais pas en incrémentant un +// pointeur. func learnMemory() (p, q *int) { - // Les valeurs retournées définies p et q ont le type pointeur int. + // Les valeurs retournées p et q auront le type pointeur int. p = new(int) // Fonction standard "new" alloue la mémoire. // Le int alloué est initialisé à 0, p n'est plus nil. s := make([]int, 20) // Alloue 20 ints en un seul bloc de mémoire. @@ -169,11 +170,12 @@ func expensiveComputation() float64 { } func learnFlowControl() { - // Bien que les "if" requiert des accolades, les parenthèses ne le sont pas. + // Bien que les "if" requièrent des accolades, les parenthèses ne sont pas + // nécessaires pour contenir le test booléen. if true { fmt.Println("voilà!") } - // Le formate est standardisé par la commande shell "go fmt." + // Le formatage du code est standardisé par la commande shell "go fmt." if false { // bing. } else { @@ -189,8 +191,9 @@ func learnFlowControl() { case 43: // Non-exécuté. } - // Comme les "if", "for" n'utilise pas de parenthèses. - // Les variables déclarées dans "for" et "if" sont locales à leur portée. + // Comme les "if", les "for" n'utilisent pas de parenthèses. + // Les variables déclarées dans les "for" et les "if" sont locales à leur + // portée. for x := 0; x < 3; x++ { // ++ est une incrémentation. fmt.Println("itération ", x) } @@ -202,8 +205,8 @@ func learnFlowControl() { continue // Non atteint. } - // Vous pouvez utiliser un "range" pour itérer dans un tableau, une slice, une - // chaîne, une map ou un channel. Les "range" retournent un canal ou deux + // Vous pouvez utiliser une "range" pour itérer dans un tableau, une slice, une + // chaîne, une map ou un canal. Les "range" retournent un canal ou deux // valeurs (tableau, slice, chaîne et map). for key, value := range map[string]int{"une": 1, "deux": 2, "trois": 3} { // pour chaque pair dans une map, affichage de la valeur et clé @@ -215,35 +218,35 @@ func learnFlowControl() { if y := expensiveComputation(); y > x { x = y } - // Les fonctions littérales est une fermeture (closure). + // Les fonctions littérales sont des fermetures. xBig := func() bool { - return x > 10000 // Réfère à la variable x déclarée en haut du "switch". + return x > 10000 } fmt.Println("xBig:", xBig()) // true (la valeur e^10 a été assignée à x). x = 1.3e3 // Ceci fait x == 1300 fmt.Println("xBig:", xBig()) // Maintenant false. - // De plus, les fonctions littérales peuvent être définies et appelée - // sur la même ligne, agissant comme argument de fonctions, tant que: + // De plus, les fonctions littérales peuvent être définies et appelées + // sur la même ligne, agissant comme argument à cette fonction, tant que: // a) la fonction littérale est appelée suite à (), // b) le résultat correspond au type de l'argument. - fmt.Println("Ajoute + multiplie deux nombres: ", + fmt.Println("Ajoute + multiplie deux nombres : ", func(a, b int) int { return (a + b) * 2 - }(10, 2)) // Appelé avec les arguments 10 et 2 - // => Ajoute + double deux nombres: 24 + }(10, 2)) // Appelle la fonction avec les arguments 10 et 2 + // => Ajoute + double deux nombres : 24 // Quand vous en aurez besoin, vous allez l'adorer. goto love love: - learnFunctionFactory() // func retournant func correspond à fun(3)(3). - learnDefer() // Un survol de cette instruction important. - learnInterfaces() // Incontournable! + learnFunctionFactory() // func retournant func correspondant à fun(3)(3). + learnDefer() // Un survol de cette instruction importante. + learnInterfaces() // Incontournable ! } func learnFunctionFactory() { - // Les deux syntaxes sont identiques, bien que la seconde est plus pratique. + // Les deux syntaxes sont identiques, bien que la seconde soit plus pratique. fmt.Println(sentenceFactory("été")("Une matinée d'", "agréable!")) d := sentenceFactory("été") @@ -287,12 +290,12 @@ func (p pair) String() string { // p s'appelle le "destinataire" } func learnInterfaces() { - // La syntaxe avec accolade défini une "structure littérale". Ceci s'évalue - // comme étant une strucutre. La syntaxe := déclare et initialise p comme - // étant cette structure. + // La syntaxe avec accolade défini une "structure littérale". Celle-ci + // s'évalue comme étant une structure. La syntaxe := déclare et initialise p + // comme étant une instance. p := pair{3, 4} fmt.Println(p.String()) // Appelle la méthode String de p, de type pair. - var i Stringer // Déclare i de l'interface de type Stringer. + var i Stringer // Déclare i instance de l'interface Stringer. i = p // Valide, car pair implémente Stringer. // Appelle la méthode String de i, de type Stringer. Retourne la même valeur // que ci-haut. @@ -307,9 +310,11 @@ func learnInterfaces() { learnVariadicParams("apprentissage", "génial", "ici!") } -// Les fonctions peuvent avoir des paramètres variables. +// Les fonctions peuvent être définie de façon à accepter un ou plusieurs +// paramètres grâce aux points de suspension, offrant une flexibilité lors de +// son appel. func learnVariadicParams(myStrings ...interface{}) { - // Itère chaque valeur du paramètre variable. + // Itère chaque paramètre dans la range. // Le tiret bas sert à ignorer l'index retourné du tableau. for _, param := range myStrings { fmt.Println("paramètre:", param) @@ -322,8 +327,8 @@ func learnVariadicParams(myStrings ...interface{}) { } func learnErrorHandling() { - // ", ok" expression utilisée pour définir si quelque chose a fonctionné ou - // non. + // ", ok" idiome utilisée pour définir si l'opération s'est déroulée avec + // succès ou non m := map[int]string{3: "trois", 4: "quatre"} if x, ok := m[1]; !ok { // ok sera faux, car 1 n'est pas dans la map. fmt.Println("inexistant") @@ -336,14 +341,14 @@ func learnErrorHandling() { // retourne: 'strconv.ParseInt: parsing "non-int": invalid syntax' fmt.Println(err) } - // Nous réviserons les interfaces un peu plus tard. Maintenant, + // Nous réviserons les interfaces un peu plus tard. Pour l'instant, learnConcurrency() } // c est un canal, un objet permettant de communiquer en simultané de façon -// sécuritaire. +// sécurisée. func inc(i int, c chan int) { - c <- i + 1 // <- est l'opérateur "destination" quand un canal apparaît à + c <- i + 1 // <- est l'opérateur "envoi" quand un canal apparaît à // gauche. } @@ -355,11 +360,11 @@ func learnConcurrency() { // Démarrage de trois goroutines simultanées. Les nombres seront incrémentés // simultanément, peut-être en paralèle si la machine le permet et configurée // correctement. Les trois utilisent le même canal. - go inc(0, c) // go est une déclaration démarrant une nouvelle goroutine. + go inc(0, c) // go est une instruction démarrant une nouvelle goroutine. go inc(10, c) go inc(-805, c) // Lis et affiche trois résultats du canal - impossible de savoir dans quel - // ordre! + // ordre ! fmt.Println(<-c, <-c, <-c) // Canal à droite, <- est l'opérateur de // "réception". @@ -374,13 +379,13 @@ func learnConcurrency() { select { case i := <-c: // La valeur reçue peut être assignée à une variable, fmt.Printf("c'est un %T", i) - case <-cs: // ou la valeur reçue peut être discartée. + case <-cs: // ou la valeur reçue peut être ignorée. fmt.Println("c'est une chaîne") case <-ccs: // Un canal vide, indisponible à la communication. fmt.Println("ne surviendra pas.") } // À ce point, une valeur a été prise de c ou cs. L'une des deux goroutines - // démarrée plus haut a complété, la seconde restera bloquée. + // démarrée plus haut a complétée, la seconde restera bloquée. learnWebProgramming() // Go permet la programmation Web. } @@ -388,17 +393,18 @@ func learnConcurrency() { // Une seule fonction du paquet http démarre un serveur Web. func learnWebProgramming() { - // Le premier paramètre de ListenAndServe is une adresse TCP à écouter. + // Le premier paramètre de ListenAndServe est une adresse TCP à écouter. // Le second est une interface, de type http.Handler. go func() { err := http.ListenAndServe(":8080", pair{}) - fmt.Println(err) // n'ignorez pas les erreurs! + fmt.Println(err) // n'ignorez pas les erreurs ! }() requestServer() } -// Fait de pair un http.Handler en implémentant sa seule méthode: ServeHTTP. +// Implémente la méthode ServeHTTP de http.Handler à pair, la rendant compatible +// avec les opérations utilisant l'interface http.Handler. func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Répondez à une requête à l'aide de la méthode http.ResponseWriter. w.Write([]byte("Vous avez appris Go en Y minutes!")) @@ -421,7 +427,7 @@ Vous pourrez y suivre le tutoriel interactif et en apprendre beaucoup plus. Une lecture de la documentation du langage est grandement conseillée. C'est facile à lire et très court (comparé aux autres langages). -Vous pouvez exécuter modifier le code sur [Go playground](https://play.golang.org/p/tnWMjr16Mm). Essayez de le modifier et de l'exécuter à partir de votre navigateur! Prennez en note que vous pouvez utiliser [https://play.golang.org](https://play.golang.org) comme un [REPL](https://en.wikipedia.org/wiki/Read-eval-print_loop) pour tester et coder dans votre navigateur, sans même avoir à installer Go. +Vous pouvez exécuter et modifier le code sur [Go playground](https://play.golang.org/p/tnWMjr16Mm). Essayez de le modifier et de l'exécuter à partir de votre navigateur! Prennez en note que vous pouvez utiliser [https://play.golang.org](https://play.golang.org) comme un [REPL](https://en.wikipedia.org/wiki/Read-eval-print_loop) pour tester et coder dans votre navigateur, sans même avoir à installer Go. Sur la liste de lecteur des étudiants de Go se trouve le [code source de la librairie standard](http://golang.org/src/pkg/). Bien documentée, elle démontre -- cgit v1.2.3 From 5e79da614c98070cfbf908af1c7be9b6abf3b2ed Mon Sep 17 00:00:00 2001 From: Adam Bard Date: Tue, 31 Mar 2015 15:46:34 -0700 Subject: Added lang tag to go-fr --- fr-fr/go-fr.html.markdown | 1 + 1 file changed, 1 insertion(+) (limited to 'fr-fr') diff --git a/fr-fr/go-fr.html.markdown b/fr-fr/go-fr.html.markdown index 2ff5902f..16558e7e 100644 --- a/fr-fr/go-fr.html.markdown +++ b/fr-fr/go-fr.html.markdown @@ -2,6 +2,7 @@ name: Go category: language language: Go +lang: fr-fr filename: learngo.go contributors: - ["Sonia Keys", "https://github.com/soniakeys"] -- cgit v1.2.3 From 5bff1e956ef8003eddfcb64ffdc1161ee3d622bc Mon Sep 17 00:00:00 2001 From: Alois Date: Thu, 30 Apr 2015 16:49:49 +0200 Subject: Create typescript-fr.html.markdown Translate the reading block, the introduction part and the type part. --- fr-fr/typescript-fr.html.markdown | 171 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 171 insertions(+) create mode 100644 fr-fr/typescript-fr.html.markdown (limited to 'fr-fr') diff --git a/fr-fr/typescript-fr.html.markdown b/fr-fr/typescript-fr.html.markdown new file mode 100644 index 00000000..e87bacac --- /dev/null +++ b/fr-fr/typescript-fr.html.markdown @@ -0,0 +1,171 @@ +--- +language: TypeScript +contributors: + - ["Philippe Vlérick", "https://github.com/pvlerick"] +translators: + - ["Alois de Gouvello", "https://github.com/aloisdg"] +filename: learntypescript-fr.ts +lang: fr-fr +--- + +TypeScript est un langage visant à faciliter le developpement d'applications large et scalable écrite en JavaScript. +TypeScript ajoute des concepts classiques comme les classes, les modules, les interfaces, les génériques et le typage statique (optionel) à JavaScript. +C'est une surcouche à JavaScript: tout le code JavaScript est valide en TypeScript ce qui permet de l'ajouter de façon transparente à n'importe quel projet. Le compilateur TypeScript émet du JavaScript. + +Cet article se concentrera seulement sur la syntaxe supplémentaire de TypeScript, plutôt que celle de [JavaScript] (../javascript/). + +Pour tester le compilateur de TypeScript, rendez-vous au [Playground] (http://www.typescriptlang.org/Playground) où vous pourrez coder, profiter d'une autocomplétion et voir directement le rendu JavaScript. + +```js +// Il y a 3 types basiques en in TypeScript +var isDone: boolean = false; +var lines: number = 42; +var name: string = "Anders"; + +// Quand c'est impossible de savoir, il ya le type `Any` +var notSure: any = 4; +notSure = "maybe a string instead"; +notSure = false; // ok, définitvement un booléen + +// Pour les collections, il y a les tableaux typés et les tableaux génériques +var list: number[] = [1, 2, 3]; // Un tableaux typé +var list: Array = [1, 2, 3]; // un tableau générique + +// Pour les énumeration +enum Color {Red, Green, Blue}; +var c: Color = Color.Green; + +// Enfin, `void` est utilisé dans le cas spécifique d'une fonction ne retournant rien +function bigHorribleAlert(): void { + alert("I'm a little annoying box!"); +} + +// Functions are first class citizens, support the lambda "fat arrow" syntax and +// use type inference + +// The following are equivalent, the same signature will be infered by the +// compiler, and same JavaScript will be emitted +var f1 = function(i: number): number { return i * i; } +// Return type inferred +var f2 = function(i: number) { return i * i; } +var f3 = (i: number): number => { return i * i; } +// Return type inferred +var f4 = (i: number) => { return i * i; } +// Return type inferred, one-liner means no return keyword needed +var f5 = (i: number) => i * i; + +// Interfaces are structural, anything that has the properties is compliant with +// the interface +interface Person { + name: string; + // Optional properties, marked with a "?" + age?: number; + // And of course functions + move(): void; +} + +// Object that implements the "Person" interface +// Can be treated as a Person since it has the name and move properties +var p: Person = { name: "Bobby", move: () => {} }; +// Objects that have the optional property: +var validPerson: Person = { name: "Bobby", age: 42, move: () => {} }; +// Is not a person because age is not a number +var invalidPerson: Person = { name: "Bobby", age: true }; + +// Interfaces can also describe a function type +interface SearchFunc { + (source: string, subString: string): boolean; +} +// Only the parameters' types are important, names are not important. +var mySearch: SearchFunc; +mySearch = function(src: string, sub: string) { + return src.search(sub) != -1; +} + +// Classes - members are public by default +class Point { + // Properties + x: number; + + // Constructor - the public/private keywords in this context will generate + // the boiler plate code for the property and the initialization in the + // constructor. + // In this example, "y" will be defined just like "x" is, but with less code + // Default values are also supported + + constructor(x: number, public y: number = 0) { + this.x = x; + } + + // Functions + dist() { return Math.sqrt(this.x * this.x + this.y * this.y); } + + // Static members + static origin = new Point(0, 0); +} + +var p1 = new Point(10 ,20); +var p2 = new Point(25); //y will be 0 + +// Inheritance +class Point3D extends Point { + constructor(x: number, y: number, public z: number = 0) { + super(x, y); // Explicit call to the super class constructor is mandatory + } + + // Overwrite + dist() { + var d = super.dist(); + return Math.sqrt(d * d + this.z * this.z); + } +} + +// Modules, "." can be used as separator for sub modules +module Geometry { + export class Square { + constructor(public sideLength: number = 0) { + } + area() { + return Math.pow(this.sideLength, 2); + } + } +} + +var s1 = new Geometry.Square(5); + +// Local alias for referencing a module +import G = Geometry; + +var s2 = new G.Square(10); + +// Generics +// Classes +class Tuple { + constructor(public item1: T1, public item2: T2) { + } +} + +// Interfaces +interface Pair { + item1: T; + item2: T; +} + +// And functions +var pairToTuple = function(p: Pair) { + return new Tuple(p.item1, p.item2); +}; + +var tuple = pairToTuple({ item1:"hello", item2:"world"}); + +// Including references to a definition file: +/// + +``` + +## Lectures complémentaires + * [Site officiel de TypeScript] (http://www.typescriptlang.org/) + * [Spécification du langage TypeScript (pdf)] (http://go.microsoft.com/fwlink/?LinkId=267238) + * [Anders Hejlsberg - Introducing TypeScript on Channel 9] (http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript) + * [Code source sur GitHub] (https://github.com/Microsoft/TypeScript) + * [Definitely Typed - repository for type definitions] (http://definitelytyped.org/) -- cgit v1.2.3 From 6f96532a59012aa1041aaf671c160396a7819167 Mon Sep 17 00:00:00 2001 From: Alois Date: Thu, 30 Apr 2015 17:12:54 +0200 Subject: Update typescript-fr.html.markdown Translate functions block --- fr-fr/typescript-fr.html.markdown | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/typescript-fr.html.markdown b/fr-fr/typescript-fr.html.markdown index e87bacac..718a5e9a 100644 --- a/fr-fr/typescript-fr.html.markdown +++ b/fr-fr/typescript-fr.html.markdown @@ -10,19 +10,19 @@ lang: fr-fr TypeScript est un langage visant à faciliter le developpement d'applications large et scalable écrite en JavaScript. TypeScript ajoute des concepts classiques comme les classes, les modules, les interfaces, les génériques et le typage statique (optionel) à JavaScript. -C'est une surcouche à JavaScript: tout le code JavaScript est valide en TypeScript ce qui permet de l'ajouter de façon transparente à n'importe quel projet. Le compilateur TypeScript émet du JavaScript. +C'est une surcouche de JavaScript : tout le code JavaScript est valide en TypeScript ce qui permet de l'ajouter de façon transparente à n'importe quel projet. Le code TypeScript est transcompilé en JavaScript par le compilateur. Cet article se concentrera seulement sur la syntaxe supplémentaire de TypeScript, plutôt que celle de [JavaScript] (../javascript/). Pour tester le compilateur de TypeScript, rendez-vous au [Playground] (http://www.typescriptlang.org/Playground) où vous pourrez coder, profiter d'une autocomplétion et voir directement le rendu JavaScript. ```js -// Il y a 3 types basiques en in TypeScript +// Il y a 3 types basiques en TypeScript var isDone: boolean = false; var lines: number = 42; var name: string = "Anders"; -// Quand c'est impossible de savoir, il ya le type `Any` +// Quand c'est impossible à déterminer, on utilise le type `Any` var notSure: any = 4; notSure = "maybe a string instead"; notSure = false; // ok, définitvement un booléen @@ -40,18 +40,18 @@ function bigHorribleAlert(): void { alert("I'm a little annoying box!"); } -// Functions are first class citizens, support the lambda "fat arrow" syntax and -// use type inference +// Les fontions sont des entités de première classe. Elles supportent les expressions lambda et +// utilisent l'inférence de types -// The following are equivalent, the same signature will be infered by the -// compiler, and same JavaScript will be emitted +// Les fonctions ci-dessous sont équivalentes, une signature identique sera inférée par le compilateur, +// et le même JavaScript sera généré var f1 = function(i: number): number { return i * i; } -// Return type inferred +// Retourne un type inféré var f2 = function(i: number) { return i * i; } var f3 = (i: number): number => { return i * i; } -// Return type inferred +// Retourne un type inféré var f4 = (i: number) => { return i * i; } -// Return type inferred, one-liner means no return keyword needed +// Retourne un type inféré, ici le mot clé `return` n'est pas nécessaire var f5 = (i: number) => i * i; // Interfaces are structural, anything that has the properties is compliant with -- cgit v1.2.3 From 0964b9e1edff08d0d4bc570a9fad135e2da45d62 Mon Sep 17 00:00:00 2001 From: Alois Date: Thu, 30 Apr 2015 18:42:13 +0200 Subject: Update typescript-fr.html.markdown Add classe block --- fr-fr/typescript-fr.html.markdown | 59 +++++++++++++++++++-------------------- 1 file changed, 28 insertions(+), 31 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/typescript-fr.html.markdown b/fr-fr/typescript-fr.html.markdown index 718a5e9a..9e6ee171 100644 --- a/fr-fr/typescript-fr.html.markdown +++ b/fr-fr/typescript-fr.html.markdown @@ -32,7 +32,7 @@ var list: number[] = [1, 2, 3]; // Un tableaux typé var list: Array = [1, 2, 3]; // un tableau générique // Pour les énumeration -enum Color {Red, Green, Blue}; +enum Color { Red, Green, Blue }; var c: Color = Color.Green; // Enfin, `void` est utilisé dans le cas spécifique d'une fonction ne retournant rien @@ -54,73 +54,70 @@ var f4 = (i: number) => { return i * i; } // Retourne un type inféré, ici le mot clé `return` n'est pas nécessaire var f5 = (i: number) => i * i; -// Interfaces are structural, anything that has the properties is compliant with -// the interface +// Les interfaces sont structurés, tout ce qui a les propriétés est compatible avec +// l'interface interface Person { name: string; - // Optional properties, marked with a "?" + // Les propriétés optionnelles sont identifiées avec un "?" age?: number; - // And of course functions + // Et bien sûr, les fonctions move(): void; } -// Object that implements the "Person" interface -// Can be treated as a Person since it has the name and move properties +// Un objet implémentant l'interface "Person" peut être traité comme +// une Person car il a les propriétés "name" et "move" var p: Person = { name: "Bobby", move: () => {} }; -// Objects that have the optional property: -var validPerson: Person = { name: "Bobby", age: 42, move: () => {} }; -// Is not a person because age is not a number -var invalidPerson: Person = { name: "Bobby", age: true }; +// Des objets implémentants la propriété optionnelle : +var validPerson: Person = { name: "Bobby", age: 42, move: () => {} }; // valide car "age" est un nombre +var invalidPerson: Person = { name: "Bobby", age: true }; // invalide car "age" n'est pas un nombre -// Interfaces can also describe a function type +// Les interfaces peuvent aussi décrire un type de fonction interface SearchFunc { (source: string, subString: string): boolean; } -// Only the parameters' types are important, names are not important. +// Seul les types des paramètres sont importants, les noms ne le sont pas var mySearch: SearchFunc; mySearch = function(src: string, sub: string) { return src.search(sub) != -1; } -// Classes - members are public by default +// Les membres des classes sont publiques par défaut class Point { - // Properties + // Propriétés x: number; - // Constructor - the public/private keywords in this context will generate - // the boiler plate code for the property and the initialization in the - // constructor. - // In this example, "y" will be defined just like "x" is, but with less code - // Default values are also supported - + // Constructeur - Les mots clés "public" et "private" dans ce contexte génèrent + // le code de la propriété et son initialisation dans le constructeur. + // Dans cet exemple, "y" sera défini de la même façon que "x", mais avec moins de code + // Les valeurs par défaut sont supportées constructor(x: number, public y: number = 0) { this.x = x; } - // Functions + // Fonctions dist() { return Math.sqrt(this.x * this.x + this.y * this.y); } - // Static members + // Membres statiques static origin = new Point(0, 0); } var p1 = new Point(10 ,20); var p2 = new Point(25); //y will be 0 -// Inheritance +// Héritage class Point3D extends Point { constructor(x: number, y: number, public z: number = 0) { - super(x, y); // Explicit call to the super class constructor is mandatory + super(x, y); // Un appel explicite au constructeur de la super classe est obligatoire. } - // Overwrite + // Redéfinition dist() { var d = super.dist(); return Math.sqrt(d * d + this.z * this.z); } } -// Modules, "." can be used as separator for sub modules +// Modules, "." peut être utilisé comme un séparateur de sous modules. module Geometry { export class Square { constructor(public sideLength: number = 0) { @@ -133,12 +130,12 @@ module Geometry { var s1 = new Geometry.Square(5); -// Local alias for referencing a module +// Alias local pour référencer un module import G = Geometry; var s2 = new G.Square(10); -// Generics +// Génériques // Classes class Tuple { constructor(public item1: T1, public item2: T2) { @@ -151,14 +148,14 @@ interface Pair { item2: T; } -// And functions +// Et fonctions var pairToTuple = function(p: Pair) { return new Tuple(p.item1, p.item2); }; var tuple = pairToTuple({ item1:"hello", item2:"world"}); -// Including references to a definition file: +// Inclure des références à un fichier : /// ``` -- cgit v1.2.3 From f5fec6341b9a7ed280a5dbfd86d9cc5ee4fa82cf Mon Sep 17 00:00:00 2001 From: Alois Date: Thu, 30 Apr 2015 18:47:21 +0200 Subject: Update typescript-fr.html.markdown Fix translation --- fr-fr/typescript-fr.html.markdown | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/typescript-fr.html.markdown b/fr-fr/typescript-fr.html.markdown index 9e6ee171..14caec7c 100644 --- a/fr-fr/typescript-fr.html.markdown +++ b/fr-fr/typescript-fr.html.markdown @@ -8,13 +8,13 @@ filename: learntypescript-fr.ts lang: fr-fr --- -TypeScript est un langage visant à faciliter le developpement d'applications large et scalable écrite en JavaScript. -TypeScript ajoute des concepts classiques comme les classes, les modules, les interfaces, les génériques et le typage statique (optionel) à JavaScript. -C'est une surcouche de JavaScript : tout le code JavaScript est valide en TypeScript ce qui permet de l'ajouter de façon transparente à n'importe quel projet. Le code TypeScript est transcompilé en JavaScript par le compilateur. +TypeScript est un langage visant à faciliter le développement d'applications large et scalable écrite en JavaScript. +TypeScript ajoute des concepts classiques comme les classes, les modules, les interfaces, les génériques et le typage statique (optionnel) à JavaScript. +C'est une sur-couche de JavaScript : tout le code JavaScript est valide en TypeScript ce qui permet de l'ajouter de façon transparente à n'importe quel projet. Le code TypeScript est transcompilé en JavaScript par le compilateur Cet article se concentrera seulement sur la syntaxe supplémentaire de TypeScript, plutôt que celle de [JavaScript] (../javascript/). -Pour tester le compilateur de TypeScript, rendez-vous au [Playground] (http://www.typescriptlang.org/Playground) où vous pourrez coder, profiter d'une autocomplétion et voir directement le rendu JavaScript. +Pour tester le compilateur de TypeScript, rendez-vous au [Playground] (http://www.typescriptlang.org/Playground) où vous pourrez coder, profiter d'une autocomplétion et accéder directement au rendu JavaScript. ```js // Il y a 3 types basiques en TypeScript -- cgit v1.2.3 From abd5437b6d94a4635df8ade836ecde2206aa9625 Mon Sep 17 00:00:00 2001 From: Alois Date: Thu, 30 Apr 2015 18:54:07 +0200 Subject: Update typescript-fr.html.markdown Adjust to 80 columns --- fr-fr/typescript-fr.html.markdown | 39 ++++++++++++++++++++++----------------- 1 file changed, 22 insertions(+), 17 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/typescript-fr.html.markdown b/fr-fr/typescript-fr.html.markdown index 14caec7c..63ed4c34 100644 --- a/fr-fr/typescript-fr.html.markdown +++ b/fr-fr/typescript-fr.html.markdown @@ -25,7 +25,7 @@ var name: string = "Anders"; // Quand c'est impossible à déterminer, on utilise le type `Any` var notSure: any = 4; notSure = "maybe a string instead"; -notSure = false; // ok, définitvement un booléen +notSure = false; // ok, définitivement un booléen // Pour les collections, il y a les tableaux typés et les tableaux génériques var list: number[] = [1, 2, 3]; // Un tableaux typé @@ -35,16 +35,17 @@ var list: Array = [1, 2, 3]; // un tableau générique enum Color { Red, Green, Blue }; var c: Color = Color.Green; -// Enfin, `void` est utilisé dans le cas spécifique d'une fonction ne retournant rien +// Enfin, `void` est utilisé dans le cas spécifique +// d'une fonction ne retournant rien function bigHorribleAlert(): void { alert("I'm a little annoying box!"); } -// Les fontions sont des entités de première classe. Elles supportent les expressions lambda et -// utilisent l'inférence de types +// Les fontions sont des entités de première classe. Elles supportent +// les expressions lambda et utilisent l'inférence de types -// Les fonctions ci-dessous sont équivalentes, une signature identique sera inférée par le compilateur, -// et le même JavaScript sera généré +// Les fonctions ci-dessous sont équivalentes, une signature identique +// sera inférée par le compilateur, et le même JavaScript sera généré var f1 = function(i: number): number { return i * i; } // Retourne un type inféré var f2 = function(i: number) { return i * i; } @@ -54,8 +55,8 @@ var f4 = (i: number) => { return i * i; } // Retourne un type inféré, ici le mot clé `return` n'est pas nécessaire var f5 = (i: number) => i * i; -// Les interfaces sont structurés, tout ce qui a les propriétés est compatible avec -// l'interface +// Les interfaces sont structurés, tout ce qui a les propriétés est compatible +// avec l'interface interface Person { name: string; // Les propriétés optionnelles sont identifiées avec un "?" @@ -68,28 +69,30 @@ interface Person { // une Person car il a les propriétés "name" et "move" var p: Person = { name: "Bobby", move: () => {} }; // Des objets implémentants la propriété optionnelle : -var validPerson: Person = { name: "Bobby", age: 42, move: () => {} }; // valide car "age" est un nombre -var invalidPerson: Person = { name: "Bobby", age: true }; // invalide car "age" n'est pas un nombre +// valide car "age" est un nombre +var validPerson: Person = { name: "Bobby", age: 42, move: () => {} }; +// invalide car "age" n'est pas un nombre +var invalidPerson: Person = { name: "Bobby", age: true }; // Les interfaces peuvent aussi décrire un type de fonction interface SearchFunc { (source: string, subString: string): boolean; } -// Seul les types des paramètres sont importants, les noms ne le sont pas +// Seul les types des paramètres sont importants, les noms ne le sont pas. var mySearch: SearchFunc; mySearch = function(src: string, sub: string) { return src.search(sub) != -1; } -// Les membres des classes sont publiques par défaut +// Les membres des classes sont publiques par défaut. class Point { // Propriétés x: number; - // Constructeur - Les mots clés "public" et "private" dans ce contexte génèrent - // le code de la propriété et son initialisation dans le constructeur. - // Dans cet exemple, "y" sera défini de la même façon que "x", mais avec moins de code - // Les valeurs par défaut sont supportées + // Constructeur - Les mots clés "public" et "private" dans ce contexte + // génèrent le code de la propriété et son initialisation dans le + // constructeur. Ici, "y" sera défini de la même façon que "x", + // mais avec moins de code. Les valeurs par défaut sont supportées. constructor(x: number, public y: number = 0) { this.x = x; } @@ -107,7 +110,9 @@ var p2 = new Point(25); //y will be 0 // Héritage class Point3D extends Point { constructor(x: number, y: number, public z: number = 0) { - super(x, y); // Un appel explicite au constructeur de la super classe est obligatoire. + // Un appel explicite au constructeur de la super classe + // est obligatoire. + super(x, y); } // Redéfinition -- cgit v1.2.3 From 288fcf7c2e03610400088381fae528294daa9f54 Mon Sep 17 00:00:00 2001 From: Alois Date: Sun, 3 May 2015 18:37:52 +0200 Subject: Create json-fr.html.markdown --- fr-fr/json-fr.html.markdown | 62 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 62 insertions(+) create mode 100644 fr-fr/json-fr.html.markdown (limited to 'fr-fr') diff --git a/fr-fr/json-fr.html.markdown b/fr-fr/json-fr.html.markdown new file mode 100644 index 00000000..9664dd73 --- /dev/null +++ b/fr-fr/json-fr.html.markdown @@ -0,0 +1,62 @@ +--- +language: json +filename: learnjson-fr.json +contributors: + - ["Anna Harren", "https://github.com/iirelu"] + - ["Marco Scannadinari", "https://github.com/marcoms"] + translators: + - ["Alois de Gouvello","https://github.com/aloisdg"] + lang: fr-fr +--- + +Comme JSON est un format d'échange de données êxtremement simple, ce Apprendre X en Y minutes +est susceptible d'être le plus simple jamais réalisé. + +JSON dans son état le plus pur n'a aucun commentaire, mais la majorité des parseurs accepterons +les commentaires du langage C (//, /\* \*/). Pour les besoins de ce document, cependant, +tout sera du JSON 100% valide. Heureusement, il s'explique par lui-même. + + +```json +{ + "Clé": "valeur", + + "Clés": "devront toujours être entourées par des guillemets", + "nombres": 0, + "chaînes de caractères": "Hellø, wørld. Tous les caractères Unicode sont autorisés, accompagné d'un \"caractère d'échappement\".", + "a des booléens ?": true, + "rien": null, + + "grand nombre": 1.2e+100, + + "objets": { + "commentaire": "La majorité de votre strucutre sera des objets.", + + "tableau": [0, 1, 2, 3, "Les tableaux peuvent contenir n'importe quoi.", 5], + + "un autre objet": { + "commentaire": "Ces choses peuvent être imbriquées. C'est très utile." + } + }, + + "bêtises": [ + { + "sources de potassium": ["bananes"] + }, + [ + [1, 0, 0, 0], + [0, 1, 0, 0], + [0, 0, 1, "neo"], + [0, 0, 0, 1] + ] + ], + + "style alternatif": { + "commentaire": "regarde ça !" + , "position de la virgule": "n'a pas d'importance - aussi longtemps qu'elle est avant la valeur, alors elle est valide." + , "un autre commentaire": "comme c'est gentil" + }, + + "C'était court": "Et, vous avez terminé. Maintenant, vous savez tout ce que JSON a à offrir." +} +``` -- cgit v1.2.3 From c09e8af49e05cfba07a95e6cc471a874fe703563 Mon Sep 17 00:00:00 2001 From: Alois Date: Sun, 3 May 2015 18:49:19 +0200 Subject: Update json-fr.html.markdown Thank you @vendethiel for your comments --- fr-fr/json-fr.html.markdown | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/json-fr.html.markdown b/fr-fr/json-fr.html.markdown index 9664dd73..dc46e043 100644 --- a/fr-fr/json-fr.html.markdown +++ b/fr-fr/json-fr.html.markdown @@ -9,11 +9,11 @@ contributors: lang: fr-fr --- -Comme JSON est un format d'échange de données êxtremement simple, ce Apprendre X en Y minutes +Comme JSON est un format d'échange de données extrêmement simple, ce Apprendre X en Y minutes est susceptible d'être le plus simple jamais réalisé. JSON dans son état le plus pur n'a aucun commentaire, mais la majorité des parseurs accepterons -les commentaires du langage C (//, /\* \*/). Pour les besoins de ce document, cependant, +les commentaires du langage C (`//`, `\* \*`). Pour les besoins de ce document, cependant, tout sera du JSON 100% valide. Heureusement, il s'explique par lui-même. -- cgit v1.2.3 From c0bfad80f0b9590081bf9e6a3cd9eea933632a29 Mon Sep 17 00:00:00 2001 From: Alois Date: Sun, 3 May 2015 20:43:17 +0200 Subject: Update typescript-fr.html.markdown Add modifications from @vendethiel's comments. See #1075 --- fr-fr/typescript-fr.html.markdown | 23 ++++++++++++----------- 1 file changed, 12 insertions(+), 11 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/typescript-fr.html.markdown b/fr-fr/typescript-fr.html.markdown index 63ed4c34..b8807104 100644 --- a/fr-fr/typescript-fr.html.markdown +++ b/fr-fr/typescript-fr.html.markdown @@ -8,9 +8,9 @@ filename: learntypescript-fr.ts lang: fr-fr --- -TypeScript est un langage visant à faciliter le développement d'applications large et scalable écrite en JavaScript. +TypeScript est un langage visant à faciliter le développement d'applications larges et scalables, écrites en JavaScript. TypeScript ajoute des concepts classiques comme les classes, les modules, les interfaces, les génériques et le typage statique (optionnel) à JavaScript. -C'est une sur-couche de JavaScript : tout le code JavaScript est valide en TypeScript ce qui permet de l'ajouter de façon transparente à n'importe quel projet. Le code TypeScript est transcompilé en JavaScript par le compilateur +C'est une surcouche de JavaScript : tout le code JavaScript est valide en TypeScript ce qui permet de l'ajouter de façon transparente à n'importe quel projet. Le code TypeScript est transcompilé en JavaScript par le compilateur. Cet article se concentrera seulement sur la syntaxe supplémentaire de TypeScript, plutôt que celle de [JavaScript] (../javascript/). @@ -22,7 +22,7 @@ var isDone: boolean = false; var lines: number = 42; var name: string = "Anders"; -// Quand c'est impossible à déterminer, on utilise le type `Any` +// Si nous ne pouvons pas déterminer le type, on utilise `Any` var notSure: any = 4; notSure = "maybe a string instead"; notSure = false; // ok, définitivement un booléen @@ -38,11 +38,11 @@ var c: Color = Color.Green; // Enfin, `void` est utilisé dans le cas spécifique // d'une fonction ne retournant rien function bigHorribleAlert(): void { - alert("I'm a little annoying box!"); + alert("Je suis une petite boîte ennuyeuse !"); } -// Les fontions sont des entités de première classe. Elles supportent -// les expressions lambda et utilisent l'inférence de types +// Les fonctions sont des entités de première classe. Le langage supporte +// les expressions lambda et utilise l'inférence de type // Les fonctions ci-dessous sont équivalentes, une signature identique // sera inférée par le compilateur, et le même JavaScript sera généré @@ -55,8 +55,8 @@ var f4 = (i: number) => { return i * i; } // Retourne un type inféré, ici le mot clé `return` n'est pas nécessaire var f5 = (i: number) => i * i; -// Les interfaces sont structurés, tout ce qui a les propriétés est compatible -// avec l'interface +// Les interfaces sont structurées, tout les objets qui ont ces propriétés +// sont compatible avec l'interface interface Person { name: string; // Les propriétés optionnelles sont identifiées avec un "?" @@ -78,7 +78,8 @@ var invalidPerson: Person = { name: "Bobby", age: true }; interface SearchFunc { (source: string, subString: string): boolean; } -// Seul les types des paramètres sont importants, les noms ne le sont pas. + +// Seul les types des paramètres sont importants. Les noms ne le sont pas. var mySearch: SearchFunc; mySearch = function(src: string, sub: string) { return src.search(sub) != -1; @@ -86,7 +87,7 @@ mySearch = function(src: string, sub: string) { // Les membres des classes sont publiques par défaut. class Point { - // Propriétés + // Propriétés x: number; // Constructeur - Les mots clés "public" et "private" dans ce contexte @@ -105,7 +106,7 @@ class Point { } var p1 = new Point(10 ,20); -var p2 = new Point(25); //y will be 0 +var p2 = new Point(25); // y sera 0 // Héritage class Point3D extends Point { -- cgit v1.2.3 From 5042c531cc1ced74ae5e12dac225ba219ff713dc Mon Sep 17 00:00:00 2001 From: Alois Date: Sun, 3 May 2015 20:58:03 +0200 Subject: Fix Markdown --- fr-fr/json-fr.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'fr-fr') diff --git a/fr-fr/json-fr.html.markdown b/fr-fr/json-fr.html.markdown index dc46e043..41d79b18 100644 --- a/fr-fr/json-fr.html.markdown +++ b/fr-fr/json-fr.html.markdown @@ -13,7 +13,7 @@ Comme JSON est un format d'échange de données extrêmement simple, ce Apprendr est susceptible d'être le plus simple jamais réalisé. JSON dans son état le plus pur n'a aucun commentaire, mais la majorité des parseurs accepterons -les commentaires du langage C (`//`, `\* \*`). Pour les besoins de ce document, cependant, +les commentaires du langage C (`//`, `/* */`). Pour les besoins de ce document, cependant, tout sera du JSON 100% valide. Heureusement, il s'explique par lui-même. -- cgit v1.2.3 From 86f406d99c829d0f3074f18346173387f1eb6064 Mon Sep 17 00:00:00 2001 From: Alois Date: Sun, 3 May 2015 20:59:27 +0200 Subject: Fix Header --- fr-fr/json-fr.html.markdown | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/json-fr.html.markdown b/fr-fr/json-fr.html.markdown index 41d79b18..49c95820 100644 --- a/fr-fr/json-fr.html.markdown +++ b/fr-fr/json-fr.html.markdown @@ -4,9 +4,9 @@ filename: learnjson-fr.json contributors: - ["Anna Harren", "https://github.com/iirelu"] - ["Marco Scannadinari", "https://github.com/marcoms"] - translators: +translators: - ["Alois de Gouvello","https://github.com/aloisdg"] - lang: fr-fr +lang: fr-fr --- Comme JSON est un format d'échange de données extrêmement simple, ce Apprendre X en Y minutes -- cgit v1.2.3 From afb44df97380cbfe037cdf5cf6bcb07355615552 Mon Sep 17 00:00:00 2001 From: chtiprog Date: Sun, 7 Dec 2014 01:47:25 +0100 Subject: Add French translation for R --- fr-fr/r-fr.html.markdown | 721 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 721 insertions(+) create mode 100644 fr-fr/r-fr.html.markdown (limited to 'fr-fr') diff --git a/fr-fr/r-fr.html.markdown b/fr-fr/r-fr.html.markdown new file mode 100644 index 00000000..8db78ef3 --- /dev/null +++ b/fr-fr/r-fr.html.markdown @@ -0,0 +1,721 @@ +--- +language: R +contributors: + - ["e99n09", "http://github.com/e99n09"] + - ["isomorphismes", "http://twitter.com/isomorphisms"] +translators: + - ["Anne-Catherine Dehier", "https://github.com/spellart"] +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. + + +```r + +# Les commentaires commencent avec des symboles numériques. + +# Il n'est pas possible de faire des commentaires multilignes, +# mais on peut superposer plusieurs commentaires comme ceci. + +# Sur Windows ou Mac, taper COMMAND-ENTER pour exécuter une ligne + + + +############################################################################# +# 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 +# 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 + +# Fait un diagramme à tiges et à feuilles (visualisation de données de +types histogramme) +stem(rivers) + + +# Le point décimal est de 2 chiffres à droite du | +# +# 0 | 4 +# 2 | 011223334555566667778888899900001111223333344455555666688888999 +# 4 | 111222333445566779001233344567 +# 6 | 000112233578012234468 +# 8 | 045790018 +# 10 | 04507 +# 12 | 1471 +# 14 | 56 +# 16 | 7 +# 18 | 9 +# 20 | +# 22 | 25 +# 24 | 3 +# 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 + +# Le point décimal est à 1 chiffre à gauche du | +# +# 48 | 1 +# 50 | +# 52 | 15578 +# 54 | 44571222466689 +# 56 | 023334677000124455789 +# 58 | 00122366666999933445777 +# 60 | 122445567800133459 +# 62 | 112666799035 +# 64 | 00011334581257889 +# 66 | 003683579 +# 68 | 0019156 +# 70 | 079357 +# 72 | 89 +# 74 | 84 +# 76 | 56 +# 78 | 4 +# 80 | +# 82 | 2 + +# Fais un histogramme : +hist(rivers, col="#333333", border="white", breaks=25) # amusez-vous avec ces parenthèses +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. +data(discoveries) +plot(discoveries, col="#333333", lwd=3, xlab="Year", + main="Number of important discoveries per year") +plot(discoveries, col="#333333", lwd=3, type = "h", xlab="Year", + main="Number of important discoveries per year") + +# Plutôt que de laisser l'ordre par défaut (par années) +# Nous pourrions aussi trier pour voir ce qu'il y a de typique +sort(discoveries) +# [1] 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 +# [26] 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 3 3 3 +# [51] 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 4 4 4 4 4 4 4 4 +# [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 +# 1 | 000000000000 +# 2 | 00000000000000000000000000 +# 3 | 00000000000000000000 +# 4 | 000000000000 +# 5 | 0000000 +# 6 | 000000 +# 7 | 0000 +# 8 | 0 +# 9 | 0 +# 10 | 0 +# 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 + +# Lance un dès quelques 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) + +# Dessine à partir d'une normale Gaussienne 9 fois +rnorm(9) +# [1] 0.07528471 1.03499859 1.34809556 -0.82356087 0.61638975 -1.88757271 +# [7] -0.59975593 0.57629164 1.08455362 + + + +################################################## +# 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 : +# les entiers, les numériques, les caractères, les logiques, et les facteurs. + +# LES ENTIERS +# 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 +length(5L) # 1 +# On peut avoir un vecteur d'entiers avec une longueur > 1 aussi : +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 +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 +5e4 # 50000 +6.02e23 # nombre d'Avogadro +1.6e-35 # longueur de Planck +# Vous pouvez également avoir des nombres infiniments grands ou petits +class(Inf) # "numeric" +class(-Inf) # "numeric" +# Vous pouvez utiliser "Inf", par exemple, dans integrate(dnorm, 3, Inf); +# Ça permet d'éviter des tableaux Z-scores. + +# 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 +# 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" : +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 +"Horatio" # "Horatio" +class("Horatio") # "character" +class('H') # "character" +# Ceux-ci sont tous les deux des vecteurs de longueur 1 +# Ici un plus long : +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 : +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 : +letters +# => +# [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s" +# [20] "t" "u" "v" "w" "x" "y" "z" +month.abb # "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov" "Dec" + +# LES TYPES LOGIQUES +# En R, un "logical" est un booléen +class(TRUE) # "logical" +class(FALSE) # "logical" +# Leur comportement est normal +TRUE == TRUE # TRUE +TRUE == FALSE # FALSE +FALSE != FALSE # FALSE +FALSE != TRUE # TRUE +# Les données manquantes (NA) sont logiques également +class(NA) # "logical" +# 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) +# ou non ordonnés (comme le sexe) +factor(c("female", "female", "male", NA, "female")) +# female female male 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 +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 +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 +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 +# => +# [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 +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 : +c(TRUE, 4) # 1 4 +c("dog", TRUE, 4) # "dog" "TRUE" "4" +as.numeric("Bilbo") +# => +# [1] NA +# Message d'avertissement : +# 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 ... + + + +################################################## +# Variables, boucles , if/else +################################################## + +# Une variable est comme une boîte où l'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 +# des instructions conditionnelles (if/else) + +# LES VARIABLES +# Beaucoup de façons d'assigner des choses : +x = 5 # c'est possible +y <- "1" # c'est préféré +TRUE -> z # ça marche mais c'est bizarre + +# LES BOUCLES +# Il y a les boucles for : +for (i in 1:4) { + print(i) +} +# Il y a les boucles while : +a <- 10 +while (a > 4) { + 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 + +# IF/ELSE +# Encore une fois assez standard +if (4 > 3) { + print("4 is greater than 3") +} else { + print("4 is not greater than 3") +} +# => +# [1] "4 is greater than 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) +} +# Appelée comme n'importe quelle autre 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 +########################################################################### + +# À UNE DIMENSION + +# 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) +vec[1] # 8 +letters[18] # "r" +LETTERS[13] # "M" +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, +head(vec, 1) # 8 +tail(vec, 2) # 10 11 +# ou trouver si un certaine valeur est dans le vecteur +any(vec == 10) # TRUE +# Si un index "dépasse" vous obtiendrez NA : +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 +vec * 4 # 16 20 24 28 +vec[2:3] * 5 # 25 30 +any(vec[2:3] == 8) # FALSE +# Et R a beaucoup de fonctions préconstruites pour résumer les vecteurs +mean(vec) # 9.5 +var(vec) # 1.666667 +sd(vec) # 1.290994 +max(vec) # 11 +min(vec) # 8 +sum(vec) # 38 +# Quelques fonctions préconstruites sympas supplémentaires : +5:15 # 5 6 7 8 9 10 11 12 13 14 15 +seq(from=0, to=31337, by=1337) +# => +# [1] 0 1337 2674 4011 5348 6685 8022 9359 10696 12033 13370 14707 +# [13] 16044 17381 18718 20055 21392 22729 24066 25403 26740 28077 29414 30751 + +# À DEUX DIMENSIONS (TOUT DANS UNE CLASSE) + +# Vous pouvez faire une matrice de toutes les entrées du même type comme ceci : +mat <- matrix(nrow = 3, ncol = 2, c(1,2,3,4,5,6)) +mat +# => +# [,1] [,2] +# [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 +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 +mat[3,2] # 6 + +# Transposer la matrice entière +t(mat) +# => +# [,1] [,2] [,3] +# [1,] 1 2 3 +# [2,] 4 5 6 + +# La multiplication de matrices +mat %*% t(mat) +# => +# [,1] [,2] [,3] +# [1,] 17 22 27 +# [2,] 22 29 36 +# [3,] 27 36 45 + +# cbind() colle des vecteurs ensemble en colonne pour faire une matrice +mat2 <- cbind(1:4, c("dog", "cat", "bird", "dog")) +mat2 +# => +# [,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 +c(class(mat2[,1]), class(mat2[,2])) + +# rbind() colle des vecteurs ensemble par lignes pour faire une matrice +mat3 <- rbind(c(1,2,4,5), c(6,7,0,4)) +mat3 +# => +# [,1] [,2] [,3] [,4] +# [1,] 1 2 4 5 +# [2,] 6 7 0 4 +# Ah, tout de la même classe. Pas de coercitions. Beaucoup mieux. + +# À DEUX DIMENSIONS (DE CLASSES DIFFÉRENTES) + +# Pour des colonnes de différents types, utiliser une trame de donnée +# Cette structure de données est si utile pour la programmation statistique, +# qu'une version a été ajoutée à Python dans le paquet "pandas". + +students <- data.frame(c("Cedric","Fred","George","Cho","Draco","Ginny"), + c(3,2,2,1,0,-1), + c("H", "G", "G", "R", "S", "G")) +names(students) <- c("name", "year", "house") # name the columns +class(students) # "data.frame" +students +# => +# name year house +# 1 Cedric 3 H +# 2 Fred 2 G +# 3 George 2 G +# 4 Cho 1 R +# 5 Draco 0 S +# 6 Ginny -1 G +class(students$year) # "numeric" +class(students[,3]) # "factor" +# Trouver les dimensions +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 +?data.frame + +# Il y a plusieurs façons tortueuses 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 +# 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 +students <- as.data.table(students) +students # note the slightly different print-out +# => +# name year house +# 1: Cedric 3 H +# 2: Fred 2 G +# 3: George 2 G +# 4: Cho 1 R +# 5: Draco 0 S +# 6: Ginny -1 G +students[name=="Ginny"] # get rows with name == "Ginny" +# => +# name year house +# 1: Ginny -1 G +students[year==2] # get rows with 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 +founders <- data.table(house=c("G","H","R","S"), + founder=c("Godric","Helga","Rowena","Salazar")) +founders +# => +# house founder +# 1: G Godric +# 2: H Helga +# 3: R Rowena +# 4: S Salazar +setkey(students, house) +setkey(founders, house) +students <- founders[students] # merge the two data sets by matching "house" +setnames(students, c("house","houseFounderName","studentName","year")) +students[,order(c("name","year","house","houseFounderName")), with=F] +# => +# studentName year house houseFounderName +# 1: Fred 2 G Godric +# 2: George 2 G Godric +# 3: Ginny -1 G Godric +# 4: Cedric 3 H Helga +# 5: Cho 1 R Rowena +# 6: Draco 0 S Salazar + +# data.table facilite le sommaire des tableaux +students[,sum(year),by=house] +# => +# house V1 +# 1: G 3 +# 2: H 3 +# 3: R 1 +# 4: S 0 + +# Pour supprimer une colonne d'une data.frame ou data.table, +# assignez-lui la valeur NULL +students$houseFounderName <- NULL +students +# => +# studentName year house +# 1: Fred 2 G +# 2: George 2 G +# 3: Ginny -1 G +# 4: Cedric 3 H +# 5: Cho 1 R +# 6: Draco 0 S + +# Supprimer une ligne en subdivisant +# En utilisant data.table : +students[studentName != "Draco"] +# => +# house studentName year +# 1: G Fred 2 +# 2: G George 2 +# 3: G Ginny -1 +# 4: H Cedric 3 +# 5: R Cho 1 +# En utilisant data.frame : +students <- as.data.frame(students) +students[students$house != "G",] +# => +# house houseFounderName studentName year +# 4 H Helga Cedric 3 +# 5 R Rowena Cho 1 +# 6 S Salazar Draco 0 + +# MULTI-DIMENSIONNELLE (TOUS ÉLÉMENTS D'UN TYPE) + +# Les arrays créent des tableaux de n dimensions +# Tous les éléments doivent être du même type +# Vous pouvez faire un tableau à 2 dimensions (une sorte de matrice) +array(c(c(1,2,4,5),c(8,9,3,6)), dim=c(2,4)) +# => +# [,1] [,2] [,3] [,4] +# [1,] 1 4 8 3 +# [2,] 2 5 9 6 +# Vous pouvez utiliser array pour faire des matrices à 3 dimensions aussi +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)) +# => +# , , 1 +# +# [,1] [,2] +# [1,] 2 8 +# [2,] 300 9 +# [3,] 4 0 +# +# , , 2 +# +# [,1] [,2] +# [1,] 5 66 +# [2,] 60 7 +# [3,] 0 847 + +# 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 +# => +# [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 +# Vous pouvez subdiviser les éléments d'une liste comme n'importe quel vecteur +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 + +################################################## +# La famille de fonction apply() +################################################## + +# Vous vous rappelez mat ? +mat +# => +# [,1] [,2] +# [1,] 1 4 +# [2,] 2 5 +# [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 +apply(mat, MAR = 2, jiggle) +# => +# [,1] [,2] +# [1,] 3 15 +# [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(). +install.packages("plyr") +require(plyr) +?plyr + + + +######################### +# Charger des données +######################### + +# "pets.csv" est un fichier sur internet +# (mais il pourrait être tout aussi facilement sur votre ordinateur) +pets <- read.csv("http://learnxinyminutes.com/docs/pets.csv") +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 +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() + +# Essayez ?read.csv et ?write.csv pour plus d'informations + + + +######################### +# Les tracés +######################### + +# LES FONCTIONS DE TRACÉS PRÉCONSTRUITES +# Les diagrammes de dispersion ! +plot(list1$time, list1$price, main = "fake data") +# Les régressions ! +linearModel <- lm(price ~ time, data = list1) +linearModel # sort le résultat de la régression +# Tracer une ligne de regression sur une tracé existant +abline(linearModel, col = "red") +# Obtenir une variété de diagnostiques sympas +plot(linearModel) +# Les histogrammes ! +hist(rpois(n = 10000, lambda = 5), col = "thistle") +# Les diagrammes en bâtons ! +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 +install.packages("ggplot2") +require(ggplot2) +?ggplot2 +pp <- ggplot(students, aes(x=house)) +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/) + + + +``` + +## How do I get 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 -- cgit v1.2.3 From a6c01bf515c02522f3ff128a7d55806908ea3871 Mon Sep 17 00:00:00 2001 From: Chtiprog Date: Sun, 3 May 2015 21:44:23 -0300 Subject: add french translation of R --- fr-fr/r-fr.html.markdown | 286 +++++++++++++++++++++++++---------------------- 1 file changed, 154 insertions(+), 132 deletions(-) (limited to 'fr-fr') 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 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 -- cgit v1.2.3 From a0ca5283d69be29bf7fa26ddd082ff927068883b Mon Sep 17 00:00:00 2001 From: Chtiprog Date: Mon, 18 May 2015 00:03:52 -0300 Subject: Refactor r french translation --- fr-fr/r-fr.html.markdown | 85 +++++++++++++++++++++++++----------------------- 1 file changed, 44 insertions(+), 41 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/r-fr.html.markdown b/fr-fr/r-fr.html.markdown index d6879c1f..3f225a0f 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 d'ensembles de données, +bibliothèques 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. +On peut également exécuter des commmandes `R` au sein d'un document LaTeX. ```r @@ -19,9 +19,11 @@ On peut également exécuter les commmandes `R` au sein d'un document LaTeX. # Les commentaires commencent avec des symboles numériques. # Il n'est pas possible de faire des commentaires multilignes, -# mais on peut superposer plusieurs commentaires comme ceci. +# mais on peut placer plusieurs commentaires les uns en dessous +# des autres comme ceci. -# Sur Windows ou Mac, taper COMMAND-ENTER pour exécuter une ligne +# Sur Mac, taper COMMAND-ENTER pour exécuter une ligne +# et sur Windows taper CTRL-ENTER @@ -43,7 +45,7 @@ head(rivers) # donne un aperçu des données length(rivers) # Combien de rivers ont été mesurées ? # 141 -summary(rivers) # Quels sont les principales données statistiques ? +summary(rivers) # Quelles 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 @@ -99,7 +101,7 @@ stem(log(rivers)) # Notez que les données ne sont ni normales # 80 | # 82 | 2 -# Fais un histogramme : +# Fait un histogramme : 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 @@ -110,7 +112,7 @@ plot(discoveries, col="#333333", lwd=3, xlab="Year", plot(discoveries, col="#333333", lwd=3, type = "h", xlab="Year", main="Number of important discoveries per year") -# Plutôt que de laisser l'ordre par défaut (par années) +# Plutôt que de laisser l'ordre par défaut (par année) # Nous pourrions aussi trier pour voir ce qu'il y a de typique sort(discoveries) # [1] 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 @@ -142,7 +144,7 @@ summary(discoveries) # Min. 1st Qu. Median Mean 3rd Qu. Max. # 0.0 2.0 3.0 3.1 4.0 12.0 -# Lance un dès plusieurs fois +# Lance un dé 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 @@ -164,11 +166,11 @@ rnorm(9) # les entiers, les numériques, les caractères, les logiques, et les facteurs. # LES ENTIERS -# Les entiers de mémoire longue sont écrit avec L +# Les entiers de type long sont écrits avec L 5L # 5 class(5L) # "integer" # (Essayez ?class pour plus d'informations sur la fonction class().) -# Avec R, chaque valeur seule, comme 5L, est considéré comme +# Avec R, chaque valeur seule, comme 5L, est considérée comme # un vecteur de longueur 1 length(5L) # 1 # On peut avoir un vecteur d'entiers avec une longueur > 1 : @@ -191,7 +193,7 @@ c(3,3,3,2,2,1) # 3 3 3 2 2 1 class(Inf) # "numeric" class(-Inf) # "numeric" # Vous pouvez utiliser "Inf", par exemple, dans integrate(dnorm, 3, Inf); -# Ça permet d'éviter des tableaux Z-scores. +# Ça permet d'éviter de réaliser une table de la loi normale. # ARITHMÉTIQUES DE BASE # Vous pouvez faire de l'arithmétique avec des nombres @@ -233,7 +235,7 @@ letters # [20] "t" "u" "v" "w" "x" "y" "z" month.abb # "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov" "Dec" -# LES TYPES LOGIQUES +# LES TYPES BOOLÉENS # En R, un "logical" est un booléen class(TRUE) # "logical" class(FALSE) # "logical" @@ -256,15 +258,16 @@ 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 -# 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) +# Les facteurs sont généralement utilisés pour y stocker des +# variables qualitatives (catégorielles). +# Les facteurs peuvent être ordonnés (comme le niveau scolaire +# des enfants) ou non ordonnés (comme le sexe) factor(c("female", "female", "male", NA, "female")) # female female male female # Les niveaux : female male -# Les "levels" sont les valeurs que les données catégorielles -# peuvent prendre +# Les facteurs possèdent un attribut appelé niveau ("level"). +# Les niveaux sont des vecteurs contenant toutes les valeurs +# que peuvent prendre les données catégorielles. # 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 @@ -288,8 +291,8 @@ parakeet # => # NULL -# LES CONTRAINTES DE TYPES -# Les contraintes de types servent à forcer une valeur à prendre +# LES CONVERSIONS DE TYPES +# Les conversions 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 @@ -304,7 +307,7 @@ 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, +# Il y a beaucoup d'autres types de données, comme les dates, # les séries temporelles, etc ... @@ -321,7 +324,7 @@ as.numeric("Bilbo") # LES VARIABLES # Beaucoup de façons d'assigner des choses : -x = 5 # c'est possible +x = 5 # c'est correct y <- "1" # c'est préféré TRUE -> z # ça marche mais c'est bizarre @@ -337,11 +340,11 @@ while (a > 4) { a <- a - 1 } # 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, +# en R. +# Des opérations sur la totalité d'un vecteur (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 +# sont préférées. # IF/ELSE # Encore une fois assez standard @@ -356,7 +359,7 @@ 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 + x = x + rnorm(1, sd=.1) # ajoute un peu de bruit (contrôlé) return(x) } # Appelées comme n'importe quelles autres fonction R : @@ -366,7 +369,7 @@ jiggle(5) # 5±ε. After set.seed(2716057), jiggle(5)==5.005043 ########################################################################## # Les structures de données : les vecteurs, les matrices, -# les data frame et les tableaux +# les data frames et les tableaux ########################################################################## # À UNE DIMENSION @@ -387,7 +390,7 @@ which(vec %% 2 == 0) # 1 3 # 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 +# ou vérifier si un certaine valeur est dans le vecteur any(vec == 10) # TRUE # Si un index "dépasse" vous obtiendrez NA : vec[6] # NA @@ -398,7 +401,7 @@ length(vec) # 4 vec * 4 # 16 20 24 28 vec[2:3] * 5 # 25 30 any(vec[2:3] == 8) # FALSE -# Et R a beaucoup de fonctions préconstruites pour résumer les vecteurs +# Et R a beaucoup de méthodes statistiques pré-construites pour les vecteurs : mean(vec) # 9.5 var(vec) # 1.666667 sd(vec) # 1.290994 @@ -425,7 +428,7 @@ mat # 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 +# Récupérer la première ligne mat[1,] # 1 4 # Réaliser une opération sur la première colonne 3 * mat[,1] # 3 6 9 @@ -502,13 +505,13 @@ dim(students) # 6 3 # stringsAsFactors = FALSE quand vous créer la data.frame ?data.frame -# Il y a plusieurs façons de subdiviser les trames de données +# Il y a plusieurs façons de subdiviser les data frames, # 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 +# Une version améliorée de la structure data.frame est data.table. # 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 : @@ -601,15 +604,15 @@ students[students$house != "G",] # MULTI-DIMENSIONNELLE (TOUS ÉLÉMENTS D'UN TYPE) -# Les arrays créent des tableaux de n dimensions -# Tous les éléments doivent être du même type +# Les arrays créent des tableaux de n dimensions. +# Tous les éléments doivent être du même type. # Vous pouvez faire un tableau à 2 dimensions (une sorte de matrice) array(c(c(1,2,4,5),c(8,9,3,6)), dim=c(2,4)) # => # [,1] [,2] [,3] [,4] # [1,] 1 4 8 3 # [2,] 2 5 9 6 -# Vous pouvez utiliser array pour faire des matrices à 3 dimensions aussi +# Vous pouvez aussi utiliser array pour faire des matrices à 3 dimensions : 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)) # => # , , 1 @@ -629,7 +632,7 @@ 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)) # LES LISTES (MULTI-DIMENSIONNELLES, ÉVENTUELLEMMENT DÉCHIRÉES, # DE DIFFÉRENTS TYPES) -# Enfin R a des listes (de vecteurs) +# Enfin, R a des listes (de vecteurs) list1 <- list(time = 1:40) list1$price = c(rnorm(40,.5*list1$time,4)) # random list1 @@ -644,10 +647,10 @@ list1[[1]] # encore une façon différente list1$price[4] # Les listes ne sont pas les structures de données les plus efficaces -# à utiliser avec R; +# à 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 +# des régressions linéaires. ########################################## # La famille de fonction apply() @@ -674,7 +677,7 @@ apply(mat, MAR = 2, jiggle) # 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(). +# Le paquet plyr vise à remplacer (et améliorer !) la famille *apply(). install.packages("plyr") require(plyr) ?plyr @@ -704,7 +707,7 @@ write.csv(pets, "pets2.csv") # to make a new .csv file # Les tracés ################ -# LES FONCTIONS DE TRACÉS PRÉCONSTRUITES +# LES FONCTIONS DE TRACÉ PRÉCONSTRUITES # Les diagrammes de dispersion ! plot(list1$time, list1$price, main = "fake data") # Les régressions ! @@ -737,7 +740,7 @@ pp + geom_point() ``` -## Comment j'obtiens R ? +## Comment obtenir R ? * 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 -- cgit v1.2.3