Julia Language
Expressions

algorithm C Language C++ Git MATLAB Language matplotlib Python Language R Language Regular Expressions tensorflow
Recherche…


Introduction aux expressions

Les expressions sont un type d'objet spécifique dans Julia. Vous pouvez penser à une expression représentant un morceau de code Julia qui n'a pas encore été évalué (c'est-à-dire exécuté). Il y a ensuite des fonctions et des opérations spécifiques, comme eval() qui évaluera l'expression.

Par exemple, nous pourrions écrire un script ou entrer dans l'interpréteur les éléments suivants: julia> 1 + 1 2

Une façon de créer une expression consiste à utiliser la syntaxe :() . Par exemple: 

julia> MyExpression = :(1+1)
:(1 + 1)
julia> typeof(MyExpression)
Expr

Nous avons maintenant un objet de type Expr . Ayant juste été formé, il ne fait rien - il se contente de rester comme tout autre objet jusqu'à ce qu'il soit agi. Dans ce cas, nous pouvons évaluer cette expression en utilisant la fonction eval() : 

julia> eval(MyExpression)
2

Ainsi, nous voyons que les deux suivants sont équivalents: 

1+1
eval(:(1+1))

Pourquoi voudrions-nous passer par la syntaxe beaucoup plus compliquée dans eval(:(1+1)) si nous voulons juste trouver ce que 1 + 1 est égal? La raison de base est que nous pouvons définir une expression à un point de notre code, la modifier éventuellement ultérieurement, puis l’évaluer ultérieurement. Cela peut potentiellement ouvrir de nouvelles fonctionnalités puissantes au programmeur Julia. Les expressions sont un élément clé de la métaprogrammation chez Julia.

Créer des expressions

Plusieurs méthodes différentes peuvent être utilisées pour créer le même type d'expression. L' introduction d'expressions a mentionné la syntaxe :() . Peut-être que le meilleur endroit pour commencer, cependant, est avec les cordes. Cela aide à révéler certaines des similarités fondamentales entre les expressions et les chaînes de caractères de Julia.

Créer une expression à partir d'une chaîne

De la documentation Julia:

Chaque programme Julia commence sa vie comme une ficelle

En d'autres termes, tout script Julia est simplement écrit dans un fichier texte, qui n'est rien d'autre qu'une chaîne de caractères. De même, toute commande Julia entrée dans un interpréteur n'est qu'une chaîne de caractères. Le rôle de Julia ou de tout autre langage de programmation est alors d'interpréter et d'évaluer les chaînes de caractères de manière logique et prévisible, de sorte que ces chaînes de caractères puissent être utilisées pour décrire ce que le programmeur souhaite que l'ordinateur accomplisse.

Ainsi, une façon de créer une expression consiste à utiliser la fonction parse() appliquée à une chaîne. L'expression suivante, une fois évaluée, affectera la valeur 2 au symbole x . 

MyStr = "x = 2"
MyExpr = parse(MyStr)
julia> x
ERROR: UndefVarError: x not defined
eval(MyExpr)
julia> x
2

Créer une expression à l'aide de :() Syntaxe 

MyExpr2 = :(x = 2)
julia> MyExpr == MyExpr2
true

Notez qu'avec cette syntaxe, Julia traitera automatiquement les noms d'objets en référence à des symboles. Nous pouvons voir cela si nous regardons les args de l'expression. (Voir Champs des objets d'expression pour plus de détails sur le champ args dans une expression.) 

julia> MyExpr2.args
2-element Array{Any,1}:
  :x
 2

Créer une expression à l'aide de la fonction Expr() 

MyExpr3 = Expr(:(=), :x, 2)
MyExpr3 == MyExpr

Cette syntaxe est basée sur la notation de préfixe . En d'autres termes, le premier argument de la fonction spécifiée pour la fonction Expr() est la head ou le préfixe. Les autres sont les arguments de l'expression. La head détermine quelles opérations seront effectuées sur les arguments.

Pour plus de détails à ce sujet, voir Champs des objets d'expression

Lorsque vous utilisez cette syntaxe, il est important de faire la distinction entre l'utilisation d'objets et de symboles pour les objets. Par exemple, dans l'exemple ci-dessus, l'expression attribue la valeur 2 au symbole :x , une opération parfaitement sensible. Si nous utilisions x lui-même dans une expression comme celle-là, nous obtiendrions un résultat absurde: 

julia> Expr(:(=), x, 5)
:(2 = 5)

De même, si nous examinons les args nous voyons: 

julia> Expr(:(=), x, 5).args
2-element Array{Any,1}:
 2
 5

Ainsi, la fonction Expr() n'effectue pas la même transformation automatique en symboles que la syntaxe :() pour créer des expressions.

Créer des expressions multilignes en utilisant les quote...end 

MyQuote = 
quote
    x = 2
    y = 3
end
julia> typeof(MyQuote)
Expr

Notez qu'avec quote...end on peut créer des expressions contenant d'autres expressions dans leur champ args : 

julia> typeof(MyQuote.args[2])
Expr

Voir Champs des objets d'expression pour plus d'informations sur ce champ args .

Plus sur la création d'expressions

Cet exemple donne simplement les bases pour créer des expressions. Voir aussi, par exemple, Interpolation et Expressions et champs des objets d'expression pour plus d'informations sur la création d'expressions plus complexes et avancées.

Champs d'objets d'expression

Comme mentionné dans l' introduction aux expressions, les expressions sont un type d'objet spécifique dans Julia. En tant que tels, ils ont des champs. Les deux champs les plus utilisés d'une expression sont sa head et ses args . Par exemple, considérons l'expression 

MyExpr3 = Expr(:(=), :x, 2)

discuté dans Création d'expressions . Nous pouvons voir la head et les args comme suit: 

julia> MyExpr3.head
:(=)

julia> MyExpr3.args
2-element Array{Any,1}:
  :x
 2

Les expressions sont basées sur la notation par préfixe . En tant que tel, la head spécifie généralement l'opération à effectuer sur les args . La tête doit être du type Julia Symbol .

Lorsqu'une expression doit affecter une valeur (lorsqu'elle est évaluée), elle utilisera généralement une tête de :(=) . Il y a bien sûr des variations évidentes à cela que l'on peut employer, par exemple: 

ex1 = Expr(:(+=), :x, 2)

: appel à la tête d'expression

Une autre commune head des expressions est :call . Par exemple 

ex2 = Expr(:call, :(*), 2, 3)
eval(ex2) ## 6

Suivant les conventions de notation des préfixes, les opérateurs sont évalués de gauche à droite. Ainsi, cette expression signifie ici que nous appellerons la fonction spécifiée sur le premier élément des args sur les éléments suivants. Nous pourrions pareillement avoir: 

julia> ex2a = Expr(:call, :(-), 1, 2, 3)
:(1 - 2 - 3)

Ou d'autres fonctions potentiellement plus intéressantes, par exemple 

julia> ex2b = Expr(:call, :rand, 2,2)
:(rand(2,2))

julia> eval(ex2b)
2x2 Array{Float64,2}:
 0.429397  0.164478
 0.104994  0.675745

Détermination automatique de la head lors de l'utilisation de :() notation de création d'expression

Notez que :call est implicitement utilisé comme tête dans certaines constructions d’expressions, par exemple 

julia> :(x + 2).head
:call

Ainsi, avec la syntaxe :() pour créer des expressions, Julia cherchera à déterminer automatiquement la tête correcte à utiliser. De même: 

julia> :(x = 2).head
:(=)

En fait, si vous n'êtes pas certain de ce que la bonne tête à utiliser pour une expression que vous créez en utilisant, par exemple, Expr() cela peut être un outil utile pour obtenir des conseils et des idées sur ce qu'il faut utiliser.

Interpolation et Expressions

La création d'expressions mentionne que les expressions sont étroitement liées aux chaînes. En tant que tels, les principes d'interpolation au sein des chaînes sont également pertinents pour les expressions. Par exemple, en interpolation de base des chaînes, on peut avoir quelque chose comme: 

n = 2
julia> MyString = "there are $n ducks"
"there are 2 ducks"

Nous utilisons le signe $ pour insérer la valeur de n dans la chaîne. Nous pouvons utiliser la même technique avec des expressions. Par exemple 

a = 2
ex1 = :(x = 2*$a)  ##     :(x = 2 * 2)
a = 3
eval(ex1)
x # 4

Contraste ceci ceci: 

a = 2
ex2 = :(x = 2*a) # :(x = 2a)
a = 3
eval(ex2)
x # 6

Ainsi, avec le premier exemple, nous définissons à l'avance la valeur de a qui sera utilisée au moment de l'évaluation de l'expression. Avec le second exemple, cependant, le compilateur Julia ne cherchera à a pour trouver sa valeur au moment de l' évaluation de notre expression.

Références externes sur les expressions

Il existe un certain nombre de ressources Web utiles qui peuvent vous aider à mieux connaître les expressions dans Julia. Ceux-ci inclus:

SO Messages:



Modified text is an extract of the original Stack Overflow Documentation
Sous licence CC BY-SA 3.0
Non affilié à Stack Overflow