adambard/learnxinyminutes-docs
1
1
Fork 0
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2024-10-05 17:18:02 +03:00
Code Issues Projects Releases Wiki Activity

Transleted code variables and strings to french

Browse Source
This commit is contained in:
Cedric HT 2016-01-23 11:31:17 +01:00
parent 0fe63187a9
commit a3e68ea324
1 changed files with 58 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

116
fr-fr/wolfram-fr.html.markdown
View File

@ -57,101 +57,101 @@ x (* 20 *)
(* Le langage Wolfram effectue des manipulations symboliques, donc utiliser des (* Le langage Wolfram effectue des manipulations symboliques, donc utiliser des
variables non déclarées n'est pas illégal *) variables non déclarées n'est pas illégal *)
cow + 5 (* 5 + cow, comme cow n'est pas déclarée, l'évaluation truc + 5 (* 5 + truc, comme truc n'est pas déclarée, l'évaluation
s'arrête là *) s'arrête là *)
cow + 5 + 10 (* 15 + cow, on évalue ce qu'on peut... *) truc + 5 + 10 (* 15 + truc, on évalue ce qu'on peut... *)
% (* 15 + cow, % représente le dernier résultat *) % (* 15 + truc, % représente le dernier résultat *)
% - cow (* 15, les variables non déclarées peuvent quand même % - truc (* 15, les variables non déclarées peuvent quand même
s'annuler *) s'annuler *)
moo = cow + 5 (* Attention : moo est ici une expression et non un nombre *) chose = truc + 5 (* Attention : chose est ici une expression et non un nombre *)
(* Déclaration d'une fonction *) (* Déclaration d'une fonction *)
Double[x_] := x * 2 (* Le symbole := empêche l'évaluation immédiate du terme Double[x_] := x * 2 (* Le symbole := empêche l'évaluation immédiate du terme
à droite *) à droite *)
Double[10] (* 20 *) Double[10] (* 20 *)
Double[Sin[Pi/2]] (* 2 *) Double[Sin[Pi/2]] (* 2 *)
Double @ Sin @ (Pi/2) (* 2, Utiliser @ évite les paquets de crochets Double @ Sin @ (Pi/2) (* 2, Utiliser @ évite les paquets de crochets
fermants si moches *) fermants si moches *)
(Pi/2) // Sin // Double(* 2, Utiliser // permet d'écrire les fonctions dans (Pi/2) // Sin // Double (* 2, Utiliser // permet d'écrire les fonctions dans
l'ordre d'appel *) l'ordre d'appel *)
(* Pour la programmation impérative, utiliser ; pour séparer les expressions *) (* Pour la programmation impérative, utiliser ; pour séparer les expressions *)
MyFirst[] := (Print@"Hello"; Print@"World") (* Les parenthèses sont nécessaires Salut[] := (Print@"Hello"; Print@"World") (* Les parenthèses sont nécessaires
car ; est prioritaire sur := *) car ; est prioritaire sur := *)
MyFirst[] (* Hello World *) Salut[] (* Hello World *)
(* Boucles For à la C *) (* Boucles For à la C *)
PrintTo[x_] := For[y=0, y<x, y++, (Print[y])] (* L'évaluation des boucles For Compter[x_] := For[y=0, y<x, y++, (Print[y])] (* L'évaluation des boucles For
se fait comme dans le C *) se fait comme dans le C *)
PrintTo[5] (* 0 1 2 3 4 *) Compter[5] (* 0 1 2 3 4 *)
(* Boucles While *) (* Boucles While *)
x = 0; While[x < 2, (Print@x; x++)] (* De nouveau, comme dans le C *) x = 0; While[x < 2, (Print@x; x++)] (* De nouveau, comme dans le C *)
(* Expressions conditionnelles et If *) (* Expressions conditionnelles et If *)
x = 8; If[x==8, Print@"Yes", Print@"No"] (* If [condition, si vrai, x = 8; If[x==8, Print@"Huit", Print@"Pas huit"] (* If [condition, si vrai,
si faux] *) si faux] *)
Switch[x, 2, Print@"Two", 8, Print@"Yes"] (* Switch par valeur *) Switch[x, 2, Print@"Deux", 8, Print@"Huit"] (* Switch par valeur *)
Which[x==2, Print@"No", x==8, Print@"Yes"] (* Switch du type if, else if, Which[x==2, Print@"Deux", x==8, Print@"Huit"] (* Switch du type if, else if,
else if, ..., else *) else if, ..., else *)
(* Les variables autres que les paramètres de fonctions sont par défaut (* Les variables autres que les paramètres de fonctions sont par défaut
globales, même à l'intérieur des fonctions *) globales, même à l'intérieur des fonctions *)
y = 10 (* 10, y est une variable globale *) y = 10 (* 10, y est une variable globale *)
PrintTo[5] (* 0 1 2 3 4 *) Compter[5] (* 0 1 2 3 4 *)
y (* 5, y a été modifiée par PrintTo *) y (* 5, y a été modifiée par Compter *)
x = 20 (* 20, x est une variable globale *) x = 20 (* 20, x est une variable globale *)
PrintTo[5] (* 0 1 2 3 4 *) Compter[5] (* 0 1 2 3 4 *)
x (* 20, dans PrintTo, le paramètre x masque la variable x (* 20, dans Compter, le paramètre x masque la variable
globale x *) globale x *)
(* La fonction Module permet d'utiliser des variables locales *) (* La fonction Module permet d'utiliser des variables locales *)
BetterPrintTo[x_] := Module[{y}, (For[y=0, y<x, y++, (Print@y)])] MieuxCompter[x_] := Module[{y}, (For[y=0, y<x, y++, (Print@y)])]
y = 20 (* y est une variable globale *) y = 20 (* y est une variable globale *)
BetterPrintTo[5] (* 0 1 2 3 4 *) MieuxCompter[5] (* 0 1 2 3 4 *)
y (* 20, y n'a pas été modifiée car le y du Module masque le y (* 20, y n'a pas été modifiée car le y du Module masque le
y global. C'est bien mieux comme ça ! *) y global. C'est bien mieux comme ça ! *)
(* Module permet de faire des déclarations globales aussi *) (* Module permet de faire des déclarations globales aussi *)
Module[{count}, count=0; (* count est une variable locale *) Module[{compte}, compte=0; (* compte est une variable locale *)
(IncCount[] := ++count); (* Ce module déclare des fonctions, mais elles (Incrementer[] := ++compte); (* Ce module déclare des fonctions, mais elles
ne sont globales. Elles ont cependant accès ne sont globales. Elles ont cependant accès
aux variables locales au module. *) aux variables locales au module. *)
(DecCount[] := --count)] (Decrementer[] := --compte)]
count (* count, car il n'y a pas de variable globale nommée compte (* compte, car il n'y a pas de variable globale nommée
count *) compte *)
IncCount[] (* 1, la fonction utilise la variable count du module *) Incrementer[] (* 1, la fonction utilise la variable compte du module *)
IncCount[] (* 2, le précédent appel de IncCount a modifié count *) Incrementer[] (* 2, le précédent appel de Incrementer a modifié compte *)
DecCount[] (* 1 *) Decrementer[] (* 1 *)
count (* count, car il n'existe toujours pas de variable globale compte (* compte, car il n'existe toujours pas de variable globale
nommé count *) nommé compte *)
(* Listes *) (* Listes *)
myList = {1, 2, 3, 4} (* {1, 2, 3, 4} *) liste = {1, 2, 3, 4} (* {1, 2, 3, 4} *)
myList[[1]] (* 1, les indexes commencent à 1 et non 0 !!! *) liste[[1]] (* 1, les indexes commencent à 1 et non 0 !!! *)
Map[Double, myList] (* {2, 4, 6, 8}, appliquer une fonction à une liste de Map[Double, liste] (* {2, 4, 6, 8}, appliquer une fonction à une liste de
manière fonctionnelle *) manière fonctionnelle *)
Double /@ myList (* {2, 4, 6, 8}, syntaxe abrégée de la ligne Double /@ liste (* {2, 4, 6, 8}, syntaxe abrégée de la ligne
précédente *) précédente *)
Scan[Print, myList] (* 1 2 3 4, boucle impérative sur une liste *) Scan[Print, liste] (* 1 2 3 4, boucle impérative sur une liste *)
Fold[Plus, 0, myList] (* 10 (0+1+2+3+4) *) Fold[Plus, 0, liste] (* 10 (0+1+2+3+4) *)
FoldList[Plus, 0, myList] (* {0, 1, 3, 6, 10}, variante de la fonction FoldList[Plus, 0, liste] (* {0, 1, 3, 6, 10}, variante de la fonction
précédente qui donne aussi les résultats précédente qui donne aussi les résultats
intermédiaires *) intermédiaires *)
Append[myList, 5] (* {1, 2, 3, 4, 5}, myList n'est pas modifiée... *) Append[liste, 5] (* {1, 2, 3, 4, 5}, liste n'est pas modifiée... *)
Prepend[myList, 5] (* {5, 1, 2, 3, 4}, ... mais elle peut l'être en Prepend[liste, 5] (* {5, 1, 2, 3, 4}, ... mais elle peut l'être en
écrivant "myList = " *) écrivant "liste = " *)
Join[myList, {3, 4}] (* {1, 2, 3, 4, 3, 4} *) Join[liste, {3, 4}] (* {1, 2, 3, 4, 3, 4} *)
myList[[2]] = 5 (* {1, 5, 3, 4}, ceci modifie bien la liste *) liste[[2]] = 5 (* {1, 5, 3, 4}, ceci modifie bien la liste *)
(* Tables associatives, ou dictionnaires *) (* Tables associatives, ou dictionnaires *)
myHash = <|"Green" -> 2, "Red" -> 1|> (* Crée une table associative *) table = <|"Vert" -> 2, "Rouge" -> 1|> (* Crée une table associative *)
myHash[["Green"]] (* 2, l'utilise *) table[["Vert"]] (* 2, l'utilise *)
myHash[["Green"]] := 5 (* 5, la modifie *) table[["Vert"]] := 5 (* 5, la modifie *)
myHash[["Puce"]] := 3.5 (* 3.5, l'étend *) table[["Bleu"]] := 3.5 (* 3.5, l'étend *)
KeyDropFrom[myHash, "Green"] (* Supprime la clé "Green" *) KeyDropFrom[table, "Vert"] (* Supprime la clé "Vert" *)
Keys[myHash] (* {Red} *) Keys[table] (* {Rouge} *)
Values[myHash] (* {1} *) Values[table] (* {1} *)
(* Pour finir, toute bonne démonstration du langage Wolfram contient un (* Pour finir, toute bonne démonstration du langage Wolfram contient un
Manipulate ! *) Manipulate ! *)