Flux de contrôle Julia
Les instructions de contrôle de flux sont implémentées en définissant une ou plusieurs instructions conditionnelles dans un programme. Lorsque la condition est vraie, le code de programme spécifié est exécuté ; lorsque la condition est fausse, un autre code spécifié est exécuté.
Julia fournit un grand nombre d'instructions de contrôle de flux :
Expressions composées:beginet;。
Expressions conditionnelles :if-elseif-elseet?:(opérateur ternaire).
Évaluation en court-circuit :opérateurs logiques&&(et) et||(ou), ainsi que les comparaisons chaînées.
Instructions de boucle :boucles :whileetfor。
Gestion des exceptions :try-catch、erroretthrow。
-
Tâche (coroutine) :yieldto。
Expressions composées
begin ... endUne expression peut évaluer séquentiellement plusieurs sous-expressions et renvoyer la valeur de la dernière sous-expression :
Exemple
x = 1
y = 2
x + y
end
3
Comme ces expressions sont très courtes, elles peuvent simplement être placées sur une seule ligne, ce qui est l'origine de la;chaîne :
Exemple
3
En pratique, il n'est pas nécessaire que le bloc begin soit multiligne, ni que la chaîne ; soit sur une seule ligne :
Exemple
3
julia> (x = 1;
y = 2;
x + y)
3
Expressions conditionnelles
Une expression conditionnelle peut décider quel bloc de code exécuter en fonction de la valeur d'une expression booléenne.
Syntaxe if-elseif-else :
/*Lorsque l'expression booléenne1est vraie, exécuter*/
elseif boolean_expression 2
/*Lorsque l'expression booléenne2est vraie, exécuter*/
elseif boolean_expression 3
/*Lorsque l'expression booléenne3est vraie, exécuter*/
else
/*Lorsqu'aucune des conditions ci-dessus n'est vraie, exécuter*/
Une instructionifpeut être suivie d'une instructionelse if...elsefacultative, qui peut être utilisée pour tester plusieurs conditions.
Lors de l'utilisation des instructions if...else if...else, les points suivants doivent être pris en compte :
- Un if peut être suivi de zéro ou un else, et le else doit venir après tous les else if.
- Un if peut être suivi de zéro ou plusieurs else if, et les else if doivent venir avant le else.
- Une fois qu'un else if correspond avec succès, les autres else if ou else ne seront pas testés.
Ci-dessous se trouve une analyse de la syntaxe conditionnelle if-elseif-else :
Exemple
println("x est inférieur à y")
elseif x > y
println("x est supérieur à y")
else
println("x est égal à y")
end
Si l'expression x < y est vraie, le bloc de code correspondant est exécuté ; sinon, l'expression conditionnelle x > y est évaluée. Si elle est vraie, le bloc de code correspondant est exécuté ; si aucune expression n'est vraie, le bloc de code else est exécuté.
Exemple
if x < y
println("x est inférieur à y")
elseif x > y
println("x est supérieur à y")
else
println("x est égal à y")
end
end
test (generic function with 1 method)
julia> test(1, 2)
x est inférieur à y
julia> test(2, 1)
x est supérieur à y
julia> test(1, 1)
x est égal à y
Opérateur ternaire
L'opérateur ternaire?:est similaire à la syntaxe if-elseif-else :
a ? b : cDans?L'expression précédente a est une expression conditionnelle. Si la condition a est vraie, l'opérateur ternaire évalue l'expression b avant le : ; si la condition a est fausse, il exécute l'expression c après le :.
Remarque :?et:Les espaces autour sont obligatoires. Une expression comme a?b:c n'est pas une expression ternaire valide (mais les sauts de ligne après ? et : sont autorisés).
Exemple
julia> println(x < y ? "less than" : "not less than")
inférieur à
julia> x = 1; y = 0;
julia> println(x < y ? "less than" : "not less than")
non inférieur à
Si l'expression x < y est vraie, l'opérateur ternaire entier exécute la chaîne "less than" ; sinon, il exécute la chaîne "not less than".
Chaînage et imbrication des opérateurs ternaires :
Exemple
x > y ? "x is greater than y" : "x is equal to y")
test (generic function with 1 method)
julia> test(1, 2)
x est inférieur à y
julia> test(2, 1)
x est supérieur à y
julia> test(1, 1)
x est égal à y
Pour faciliter le chaînage des valeurs, les opérateurs sont associés de droite à gauche.
Semblable à if-elseif-else, les expressions avant et après:sont exécutées en conséquence uniquement lorsque l'expression conditionnelle est vraie ou fausse :
Exemple
v (fonction générique avec 1 méthode)
julia> 1 < 2 ? v("yes") : v("no")
oui
"yes"
julia> 1 > 2 ? v("yes") : v("no")
non
"no"
Évaluation par court-circuit
En Julia, les opérateurs&&et||correspondent aux"et"et"ou" logiquesopérations.
- Dans l'expression
a && b, la sous-expressionbest exécuté uniquement lorsqueaesttrue; si a est false, false est renvoyé directement. - Dans l'expression
a || b, la sous-expressionbest exécuté uniquement lorsqueaestfalse; si a est true, a est renvoyé directement.
&& Exemple
┌ Avertissement : Un nombre impair!
└ @ Main REPL[5]:1
julia> isodd(4) && @warn("Un nombre impair !")
false
|| Exemple
vrai
julia> isodd(4) || @warn("Un nombre impair !")
┌ Avertissement : Un nombre impair!
└ @ Main REPL[8]:1
&& et || dépendent tous les deux du côté droit, mais && a une priorité plus élevée que ||. Voir l'exemple :
Exemple
t (fonction générique avec 1 méthode)
julia> f(x) = (println(x); false)
f (fonction générique avec 1 méthode)
julia> t(1) && t(2)
1
2
vrai
julia> t(1) && f(2)
1
2
false
julia> f(1) && t(2)
1
false
julia> f(1) && f(2)
1
false
julia> t(1) || t(2)
1
vrai
julia> t(1) || f(2)
1
vrai
julia> f(1) || t(2)
1
2
vrai
julia> f(1) || f(2)
1
2
false
Instructions de boucle
Les instructions de boucle utilisentwhileetfordeux mots-clés pour être implémentées.
Voici un exemple de bouclewhile:
Exemple
julia> while i <= 5
println(i)
global i += 1
end
1
2
3
4
5
La boucle while évalue l'expression conditionnelle (i <= 5). Tant qu'elle est vraie, elle continue d'exécuter le corps de la boucle while. Lorsque l'expression conditionnelle est fausse, c'est-à-dire lorsque i = 6, la boucle se termine.
La boucle for est plus pratique à utiliser. L'exemple ci-dessus implémenté avec une boucle for est le suivant :
Exemple
println(i)
end
1
2
3
4
5
Ici,1:5est un objet de plage représentant la séquence de nombres 1, 2, 3, 4, 5.
La boucle for itère sur ces valeurs, en assignant chaque variable i.
Une différence très importante entre la boucle for et la boucle while précédente est la portée, c'est-à-dire la visibilité des variables. Si la variable i n'a pas été introduite dans une autre portée, à l'intérieur de la boucle for elle n'est visible qu'au sein de la boucle for, et n'est pas visible à l'extérieur ni après celle-ci. Vous avez besoin d'une nouvelle instance de session interactive ou d'un nouveau nom de variable pour tester cette fonctionnalité :
Exemple
println(j)
end
1
2
3
4
5
julia> j
ERROR: UndefVarError: j not defined
En général, les composants de la boucle for peuvent être utilisés pour itérer sur n'importe quel conteneur. Dans ce cas, comparé à =, l'autre mot-clé (mais complètement identique)inou∈est plus couramment utilisé parce qu'il rend le code plus clair :
Exemple
println(i)
end
1
4
0
julia> for s ∈ ["foo","bar","baz"]
println(s)
end
foo
bar
baz
Par commodité, nous pouvons terminer une boucle while avant que la condition de test ne devienne fausse, ou arrêter une boucle for avant d'atteindre la fin de l'objet itéré. Cela peut être fait avec le mot-clébreak:
Exemple
julia> while true
println(i)
if i >= 5
break
end
global i += 1
end
1
2
3
4
5
julia> for j = 1:1000
println(j)
if j >= 5
break
end
end
1
2
3
4
5
Sans le mot-clé break, la boucle while ci-dessus ne se terminerait jamais d'elle-même, et la boucle for itérerait jusqu'à 1000. Ces boucles peuvent toutes utiliser break pour se terminer plus tôt.
Dans certains scénarios, il est nécessaire de terminer l'itération en cours directement et de passer immédiatement à l'itération suivante. Le mot-clécontinuepeut être utilisé pour ce faire :
Exemple
if i % 3 != 0
continue
end
println(i)
end
3
6
9
Il s'agit d'un exemple quelque peu artificiel, car nous pourrions obtenir la même fonctionnalité de manière plus concise en niant la condition et en plaçant l'appel à println à l'intérieur d'un bloc if. Dans des applications pratiques, il y a davantage de code à exécuter après continue, et il peut y avoir plusieurs endroits où continue est appelé.
Plusieurs boucles for imbriquées peuvent être fusionnées en une seule boucle externe, qui peut servir à créer le produit cartésien de leurs objets itérés :
Exemple
println((i, j))
end
(1, 3)
(1, 4)
(2, 3)
(2, 4)
Avec cette syntaxe, les variables d'itération peuvent toujours être utilisées normalement avec les variables de boucle pour l'indexation. Par exemple,for i = 1:n, j = 1:iest valide, mais utiliser une instruction break à l'intérieur d'une boucle interrompra l'ensemble de la boucle imbriquée, pas seulement la boucle interne. À chaque exécution de la boucle interne, les variables (i et j) reçoivent leurs valeurs d'itération actuelles. Ainsi, les affectations à i ne sont pas visibles pour les itérations suivantes :
Exemple
println((i, j))
i = 0
end
(1, 3)
(1, 4)
(2, 3)
(2, 4)
Si cet exemple est réécrit en utilisant un mot-clé for pour chaque variable, la sortie sera différente : les deuxième et quatrième variables contiennent 0.
Vous pouvez utiliser zip pour parcourir simultanément plusieurs conteneurs dans une seule boucle for :
Exemple
println((j,k))
end
(1, 4)
(2, 5)
(3, 6)
julia> for x in zip(0:15, 100:110, 200:210)
println(x)
end
(0, 100, 200)
(1, 101, 201)
(2, 102, 202)
(3, 103, 203)
(4, 104, 204)
(5, 105, 205)
(6, 106, 206)
(7, 107, 207)
(8, 108, 208)
(9, 109, 209)
(10, 110, 210)
// Gérer les nombres d'éléments incohérents
julia> for x in zip(0:10, 100:115, 200:210)
println(x)
end
(0, 100, 200)
(1, 101, 201)
(2, 102, 202)
(3, 103, 203)
(4, 104, 204)
(5, 105, 205)
(6, 106, 206)
(7, 107, 207)
(8, 108, 208)
(9, 109, 209)
(10, 110, 210)
L'utilisation de zip crée un itérateur qui est un tuple de sous-itérateurs pour les conteneurs qui lui sont passés. L'itérateur zip parcourt tous les sous-itérateurs dans l'ordre, en sélectionnant le ii-ième élément de chaque sous-itérateur à la ii-ième itération de la boucle for. Dès qu'un sous-itérateur est épuisé, la boucle for s'arrête.
Les instructions for peuvent imbriquer plusieurs conditions de boucle, en utilisant des virgules,pour les séparer :
Exemple
@show (n, m)
end
(n, m) = (1, 1)
(n, m) = (1, 2)
(n, m) = (1, 3)
(n, m) = (1, 4)
(n, m) = (1, 5)
(n, m) = (2, 1)
(n, m) = (2, 2)
(n, m) = (2, 3)
(n, m) = (2, 4)
(n, m) = (2, 5)
(n, m) = (3, 1)
(n, m) = (3, 2)
(n, m) = (3, 3)
(n, m) = (3, 4)
(n, m) = (3, 5)
(n, m) = (4, 1)
(n, m) = (4, 2)
(n, m) = (4, 3)
(n, m) = (4, 4)
(n, m) = (4, 5)
(n, m) = (5, 1)
(n, m) = (5, 2)
(n, m) = (5, 3)
(n, m) = (5, 4)
(n, m) = (5, 5)
Compréhensions
Une compréhension est une méthode de traitement de données particulière qui peut construire une nouvelle structure de séquence de données à partir d'une séquence de données.Le format est le suivant :
[out_exp_res for out_exp in input_list]
ou
[expressionforvariableinlistifcondition]
[out_exp_res for out_exp in input_list if condition]
Exemple
5-element Array{Int64,1}:
1
4
9
16
25
Nous pouvons également spécifier le type des éléments que nous voulons générer :
Exemple
5-element Array{Complex,1}:
1 + 0im
4 + 0im
9 + 0im
16 + 0im
25 + 0im
Parcours de tableaux
Parfois, nous voulons parcourir chaque élément d'un tableau, y compris l'indice de l'élément.
Julia fournit laen(iter)fonction ; le paramètreiterest un objet itérable. Cette fonction générera les numéros d'index ainsi que la valeur correspondant à chaque index.
Exemple
julia> for (index, value) in enumerate(a)
println("$index $value")
end
1 a
2 b
3 c
julia> arr = rand(0:9, 4, 4)
4×4 Array{Int64,2}:
7 6 5 8
8 6 9 4
6 3 0 7
2 3 2 4
julia> [x for x in enumerate(arr)]
4×4 Array{Tuple{Int64,Int64},2}:
(1, 7) (5, 6) (9, 5) (13, 8)
(2, 8) (6, 6) (10, 9) (14, 4)
(3, 6) (7, 3) (11, 0) (15, 7)
(4, 2) (8, 3) (12, 2) (16, 4)
Gestion des exceptions
Lors de l'exécution du programme, si une condition inattendue se produit, une fonction peut être incapable de renvoyer une valeur raisonnable à son appelant. Dans de tels cas, il est préférable de laisser la condition inattendue terminer le programme et imprimer des informations de débogage d'erreur, ce qui permet aux développeurs de gérer plus facilement leur code.
Grâce à l'instructiontry / catch, les exceptions peuvent être gérées facilement.
Par exemple, dans le code ci-dessous, la fonction racine carrée sqrt lève une exception. Grâce à try / catch, nous pouvons afficher précisément les informations sur l'exception.
Exemple
sqrt("ten")
catch e
println("You need to enter a number")
end
Vous devez saisir un nombre
Clause finally
Lorsque l'on programme avec des changements d'état ou que l'on utilise des ressources telles que des fichiers, il est souvent nécessaire d'effectuer un travail de nettoyage (comme fermer des fichiers) lorsque le code se termine. Comme les exceptions peuvent faire sortir certains blocs de code avant leur fin normale, cela peut compliquer le travail ci-dessus. Le mot-clé finally permet d'exécuter un certain morceau de code lorsqu'un bloc de code se termine, quelle que soit la façon dont il se termine.
Voici un exemple qui garantit qu'un fichier ouvert est fermé :
Exemple
try
# opérer sur le fichier f
finally
close(f)
end
Lorsque le flux de contrôle quitte le bloc try (par exemple, lorsque return est rencontré, ou lorsqu'il se termine normalement), close(f) sera exécuté. Si le bloc try sort à cause d'une exception, l'exception continue à se propager. Le bloc catch peut être utilisé avec try et finally. Dans ce cas, le bloc finally s'exécute après que catch a traité l'erreur.
Fonction throw
Nous pouvons utiliser throw pour créer explicitement des exceptions.
Par exemple, si une fonction n'est définie que pour les nombres non négatifs, vous pouvez utiliser throw pour lever une DomainError lorsque le paramètre d'entrée est négatif.
Exemple
f (fonction générique avec 1 méthode)
julia> f(1)
0.36787944117144233
julia> f(-1)
ERREUR : DomainError avec -1:
l'argument doit être non négatif
Trace de pile :
[1] f(::Int64) à ./none:1
Notez que DomainError sans parenthèses n'est pas une exception, mais un type d'exception. Nous devons l'appeler pour obtenir un objet Exception :
Exemple
vrai
julia> typeof(DomainError) <: Exception
false
En outre, certains types d'exception acceptent un ou plusieurs arguments pour le signalement des erreurs :
Exemple
ERREUR : UndefVarError : x non défini
Nous pouvons facilement implémenter ce mécanisme avec un type d'exception personnalisé, en suivant le modèle d'UndefVarError :
Exemple
var::Symbol
end
julia> Base.showerror(io::IO, e::MyUndefVarError) = print(io, e.var, " non défini")
Task (Coroutine)
Task (coroutine) fournit un contrôle de flux non local, ce qui permet de basculer entre des tâches de calcul temporairement suspendues. Nous aborderons cela en détail dans le chapitre ultérieur sur la programmation asynchrone.
Autres extensions