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

julia> z = begin
           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

julia> z = (x = 1; y = 2; x + y)
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

julia> begin x = 1; y = 2; x + y end
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 :

if boolean_expression 1
   /*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

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

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

julia> function test(x, y)
           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 : c

Dans?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> x = 1; y = 2;

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

julia> test(x, y) = println(x < y ? "x is less than y"    :
                            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

julia> v(x) = (println(x); x)
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'expressiona && b, la sous-expressionbest exécuté uniquement lorsqueaesttrue; si a est false, false est renvoyé directement.
  • Dans l'expressiona || b, la sous-expressionbest exécuté uniquement lorsqueaestfalse; si a est true, a est renvoyé directement.

&& Exemple

julia> isodd(3) && @warn("Un nombre impair !")
┌ Avertissement : Un nombre impair!
└ @ Main REPL[5]:1

julia> isodd(4) && @warn("Un nombre impair !")
false

|| Exemple

julia> isodd(3) || @warn("Un nombre impair !")
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

julia> t(x) = (println(x); true)
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> i = 1;

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

julia> for i = 1:5
           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

julia> for j = 1:5
           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

julia> for i in [1,4,0]
           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> i = 1;

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

julia> for i = 1:10
           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

julia> for i = 1:2, j = 3:4
           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

julia> for i = 1:2, j = 3:4
           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

julia> for (j, k) in zip([1 2 3], [4 5 6 7])
           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

julia> for n in 1:5, m in 1:5
                  @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 :

[expressionforvariableinlist]
[out_exp_res for out_exp in input_list]

ou

[expressionforvariableinlistifcondition]
[out_exp_res for out_exp in input_list if condition]


Exemple

julia> [X^2 for X in 1:5]
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

julia> Complex[X^2 for X in 1:5]
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> a = ["a", "b", "c"];

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

julia> try
         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

f = open("file")
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

julia> f(x) = x>=0 ? exp(-x) : throw(DomainError(x, "l'argument doit être non négatif"))
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

julia> typeof(DomainError(nothing)) <: Exception
vrai

julia> typeof(DomainError) <: Exception
false

En outre, certains types d'exception acceptent un ou plusieurs arguments pour le signalement des erreurs :

Exemple

julia> throw(UndefVarError(:x))
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

julia> struct MyUndefVarError <: Exception
           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