Julia Language
Ausdrücke

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


Einführung in Ausdrücke

Ausdrücke sind ein spezieller Objekttyp in Julia. Sie können sich einen Ausdruck als einen Teil des Julia-Codes vorstellen, der noch nicht ausgewertet wurde (dh ausgeführt wurde). Es gibt dann bestimmte Funktionen und Operationen, wie eval() die den Ausdruck auswerten.

Zum Beispiel könnten wir ein Skript schreiben oder in den Interpreter folgendes eingeben: julia> 1 + 1 2

Eine Möglichkeit zum Erstellen eines Ausdrucks ist die Syntax :() . Zum Beispiel: 

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

Wir haben jetzt ein Expr Typ Expr . Gerade erst gebildet, tut es nichts - es sitzt einfach wie jedes andere Objekt herum, bis es reagiert wird. In diesem Fall können wir diesen Ausdruck mit der Funktion eval() auswerten : 

julia> eval(MyExpression)
2

So sehen wir, dass die folgenden zwei gleichwertig sind: 

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

Warum sollten wir die viel kompliziertere Syntax in eval(:(1+1)) durchgehen, wenn wir nur herausfinden wollen, was 1 + 1 gleich ist? Der Hauptgrund ist, dass wir einen Ausdruck an einer Stelle in unserem Code definieren, ihn möglicherweise später ändern und ihn später noch auswerten können. Dies kann dem Julia-Programmierer potentiell neue Möglichkeiten eröffnen. Ausdrücke sind eine Schlüsselkomponente der Metaprogrammierung in Julia.

Ausdrücke erstellen

Es gibt verschiedene Methoden, um denselben Ausdruckstyp zu erstellen. Das Intro für Ausdrücke erwähnte die :() Syntax. Der beste Startplatz ist jedoch vielleicht mit Schnüren. Dies hilft, einige der grundlegenden Ähnlichkeiten zwischen Ausdrücken und Strings in Julia aufzuzeigen.

Erstellen Sie einen Ausdruck aus Zeichenfolge

Aus der Julia- Dokumentation :

Jedes Julia-Programm beginnt als Zeichenfolge

Mit anderen Worten, jedes Julia-Skript wird einfach in eine Textdatei geschrieben, die nur aus einer Zeichenfolge besteht. Ebenso ist jeder Julia-Befehl, der in einen Interpreter eingegeben wird, nur eine Zeichenfolge. Die Rolle von Julia oder einer anderen Programmiersprache besteht dann darin, Zeichenfolgen auf logische und vorhersagbare Weise zu interpretieren und zu bewerten, sodass diese Zeichenfolgen verwendet werden können, um zu beschreiben, was der Programmierer vom Computer erreichen möchte.

Daher besteht eine Möglichkeit zum Erstellen eines Ausdrucks darin, die Funktion parse() als auf einen String angewendet zu verwenden. Der folgende Ausdruck weist nach der Auswertung dem Symbol x den Wert 2 zu. 

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

Erstellen Sie einen Ausdruck mit :() Syntax 

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

Beachten Sie, dass Julia mit dieser Syntax die Namen von Objekten automatisch als Verweis auf Symbole behandelt. Wir können das sehen, wenn wir die args des Ausdrucks betrachten. (Weitere Informationen zum Feld args in einem Ausdruck finden Sie unter Felder mit Ausdrucksobjekten.) 

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

Erstellen Sie einen Ausdruck mit der Funktion Expr() 

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

Diese Syntax basiert auf der Präfixnotation . Mit anderen Worten ist das erste Argument der für die Funktion Expr() Funktion der head oder das Präfix. Die restlichen sind die arguments des Ausdrucks. Der head bestimmt, welche Operationen an den Argumenten ausgeführt werden.

Weitere Informationen hierzu finden Sie unter Felder mit Ausdrucksobjekten

Bei der Verwendung dieser Syntax ist es wichtig, zwischen Objekten und Symbolen für Objekte zu unterscheiden. Im obigen Beispiel weist der Ausdruck beispielsweise dem Symbol den Wert 2 zu :x , eine absolut sinnvolle Operation. Wenn wir in einem solchen Ausdruck x selbst verwenden, erhalten wir das unsinnige Ergebnis: 

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

Wenn wir die args , sehen wir: 

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

Daher führt die Funktion Expr() nicht die gleiche automatische Umwandlung in Symbole durch wie die Syntax :() zum Erstellen von Ausdrücken.

Erstellen Sie mehrzeilige Ausdrücke mit quote...end 

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

Beachten Sie, dass wir mit quote...end Ausdrücke erstellen können, die andere Ausdrücke in ihrem args : 

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

Weitere args zu diesem args Sie unter Felder mit Ausdrucksobjekten .

Weitere Informationen zum Erstellen von Ausdrücken

Dieses Beispiel enthält lediglich die Grundlagen zum Erstellen von Ausdrücken. Weitere Informationen zum Erstellen komplexerer und erweiterter Ausdrücke finden Sie auch unter Interpolation und Ausdrücke und Felder von Ausdrucksobjekt.

Felder von Ausdrucksobjekten

Wie in der Einführung zu Ausdrücken erwähnt, sind Ausdrücke ein spezieller Objekttyp in Julia. Als solche haben sie Felder. Die zwei am häufigsten verwendeten Felder eines Ausdrucks sind der head und die args . Betrachten Sie zum Beispiel den Ausdruck 

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

in Erstellen von Ausdrücken behandelt . Wir können den head und die args wie folgt sehen: 

julia> MyExpr3.head
:(=)

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

Ausdrücke basieren auf der Präfixnotation . Der head spezifiziert im Allgemeinen die Operation, die an den args . Der Kopf muss ein Julia- Symbol .

Wenn ein Ausdruck einen Wert zuweisen soll (wenn er ausgewertet wird), verwendet er im Allgemeinen einen Kopf von :(=) . Es gibt natürlich offensichtliche Variationen, die verwendet werden können, zB: 

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

: Aufruf zum Ausdruck Köpfe

Ein weiterer gemeinsamer head für Ausdrücke ist :call . Z.B 

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

Nach den Konventionen der Präfixnotation werden Operatoren von links nach rechts ausgewertet. Daher bedeutet dieser Ausdruck hier, dass wir die Funktion aufrufen, die im ersten Element von args in den nachfolgenden Elementen angegeben ist. In ähnlicher Weise könnten wir 

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

Oder andere, möglicherweise interessantere Funktionen, z 

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

Automatische Ermittlung des head bei Verwendung von :() Ausdruckserstellungsnotation

Beachten Sie, dass :call in bestimmten Ausdruckskonstruktionen der :call implizit als Kopf verwendet wird, z 

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

Mit der Syntax :() zum Erstellen von Ausdrücken versucht Julia daher automatisch, den richtigen zu verwendenden Kopf zu ermitteln. Ähnlich: 

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

Wenn Sie nicht sicher sind, was der richtige Kopf für einen Ausdruck ist, den Sie zum Beispiel mit Expr() formen, kann dies ein hilfreiches Werkzeug sein, um Tipps und Ideen zu erhalten.

Interpolation und Ausdrücke

Das Erstellen von Ausdrücken erwähnt, dass Ausdrücke eng mit Strings zusammenhängen. Daher sind die Interpolationsprinzipien in Strings auch für Ausdrücke relevant. Bei der grundlegenden String-Interpolation können wir beispielsweise Folgendes haben: 

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

Wir verwenden das $ -Zeichen, um den Wert von n in die Zeichenfolge einzufügen. Wir können dieselbe Technik mit Ausdrücken verwenden. Z.B 

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

Im Gegensatz dazu dies: 

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

Im ersten Beispiel setzen wir also vorab den Wert von a , der zum Zeitpunkt der Auswertung des Ausdrucks verwendet wird. Mit dem zweiten Beispiel werden jedoch die Julia - Compiler nur schauen a , um seinen Wert zum Zeitpunkt der Auswertung für unseren Ausdruck zu finden.

Externe Verweise auf Ausdrücke

Es gibt eine Reihe nützlicher Webressourcen, mit denen Sie Ihr Wissen über Ausdrücke in Julia erweitern können. Diese schließen ein:

SO Beiträge:



Modified text is an extract of the original Stack Overflow Documentation
Lizenziert unter CC BY-SA 3.0
Nicht angeschlossen an Stack Overflow