Julia Language
Uitdrukkingen

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


Inleiding tot uitdrukkingen

Uitdrukkingen zijn een specifiek type object in Julia. U kunt denken dat een uitdrukking een stuk Julia-code vertegenwoordigt dat nog niet is geëvalueerd (dwz uitgevoerd). Er zijn dan specifieke functies en bewerkingen, zoals eval() die de uitdrukking evalueren.

We kunnen bijvoorbeeld een script schrijven of de volgende tolk invoeren: julia> 1 + 1 2

Een manier om een uitdrukking te maken is met behulp van de :() syntaxis. Bijvoorbeeld: 

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

We hebben nu een Expr type object. Het is net gevormd en doet niets - het blijft gewoon rondhangen als elk ander object totdat er iets op wordt gedaan. In dit geval kunnen we die uitdrukking evalueren met de functie eval() : 

julia> eval(MyExpression)
2

We zien dus dat de volgende twee gelijkwaardig zijn: 

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

Waarom zouden we door de veel gecompliceerdere syntaxis in eval(:(1+1)) als we gewoon willen vinden wat 1 + 1 gelijk is? De basisreden is dat we een uitdrukking op een bepaald punt in onze code kunnen definiëren, deze mogelijk later kunnen wijzigen en deze op een later tijdstip nog kunnen evalueren. Dit kan mogelijk krachtige nieuwe mogelijkheden bieden voor de Julia-programmeur. Expressies zijn een belangrijk onderdeel van metaprogrammering in Julia.

Uitdrukkingen maken

Er zijn een aantal verschillende methoden die kunnen worden gebruikt om hetzelfde type expressie te maken. De uitdrukkingen intro vermeldden de :() syntaxis. Misschien is de beste plaats om te beginnen, echter met strijkers. Dit helpt om enkele van de fundamentele overeenkomsten tussen uitdrukkingen en tekenreeksen in Julia te onthullen.

Creëer expressie van string

Uit de Julia- documentatie :

Elk Julia-programma begint het leven als een string

Met andere woorden, elk Julia-script wordt eenvoudig geschreven in een tekstbestand, dat niets anders is dan een reeks tekens. Evenzo is elk Julia-commando dat in een tolk wordt ingevoerd slechts een reeks tekens. De rol van Julia of een andere programmeertaal is dan om tekenreeksen op een logische, voorspelbare manier te interpreteren en evalueren, zodat die tekenreeksen kunnen worden gebruikt om te beschrijven wat de programmeur wil dat de computer bereikt.

Een manier om een uitdrukking te maken is dus om de functie parse() te gebruiken zoals toegepast op een tekenreeks. De volgende uitdrukking zal, zodra deze is geëvalueerd, de waarde 2 toekennen aan het symbool x . 

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

Maak een expressie met :() Syntaxis 

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

Let op: met deze syntaxis behandelt Julia automatisch de namen van objecten als verwijzingen naar symbolen. We kunnen dit zien als we kijken naar de args van de uitdrukking. (Zie Expression Fields of Expression Objects voor meer informatie over het veld args in een expressie.) 

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

Maak expressie met de functie Expr() 

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

Deze syntaxis is gebaseerd op voorvoegselnotatie . Met andere woorden, het eerste argument van de opgegeven functie voor de functie Expr() is de head of het voorvoegsel. De overige zijn de arguments van de uitdrukking. Het head bepaalt welke bewerkingen op de argumenten worden uitgevoerd.

Zie Fields of Expression Objects voor meer informatie hierover

Bij het gebruik van deze syntaxis is het belangrijk om onderscheid te maken tussen het gebruik van objecten en symbolen voor objecten. In het bovenstaande voorbeeld kent de uitdrukking bijvoorbeeld de waarde 2 aan het symbool :x , een volkomen verstandige bewerking. Als we x zelf in een dergelijke uitdrukking zouden gebruiken, zouden we het onzinnige resultaat krijgen: 

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

Evenzo, als we de args onderzoeken, zien we: 

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

De functie Expr() voert dus niet dezelfde automatische transformatie naar symbolen uit als de syntaxis :() voor het maken van expressies.

Maak expressies met meerdere regels met quote...end 

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

Merk op dat we met quote...end uitdrukkingen kunnen maken die andere uitdrukkingen in hun args veld bevatten: 

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

Zie Expression Fields of Expression Objects voor meer informatie over dit args veld.

Meer over het maken van expressies

Dit voorbeeld geeft alleen de basis voor het maken van expressies. Zie ook bijvoorbeeld Interpolatie en expressies en Velden met expressie-objecten voor meer informatie over het maken van complexere en geavanceerde expressies.

Velden van expressieobjecten

Zoals vermeld in de inleiding tot uitdrukkingen zijn uitdrukkingen een specifiek type object in Julia. Als zodanig hebben ze velden. De twee meest gebruikte velden van een uitdrukking zijn de head en de args . Overweeg bijvoorbeeld de uitdrukking 

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

besproken in Expressies maken . We kunnen het head en de args als volgt zien: 

julia> MyExpr3.head
:(=)

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

Uitdrukkingen zijn gebaseerd op voorvoegselnotatie . Als zodanig specificeert de head algemeen de bewerking die moet worden uitgevoerd op de args . Het hoofd moet van Julia type Symbol .

Wanneer een uitdrukking een waarde moet toekennen (wanneer deze wordt geëvalueerd), zal deze over het algemeen een kop gebruiken van :(=) . Er zijn natuurlijk duidelijke variaties hierop die kunnen worden gebruikt, bijvoorbeeld: 

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

: oproep voor expressiehoofden

Een ander veel voorkomend head voor uitdrukkingen is :call . Eg 

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

Volgens de conventies van prefixnotatie worden operators van links naar rechts geëvalueerd. Deze uitdrukking betekent hier dus dat we de functie aanroepen die is opgegeven voor het eerste element van args voor de volgende elementen. We zouden op dezelfde manier kunnen hebben: 

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

Of andere, mogelijk interessantere functies, bijv 

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 bepaling van het head bij gebruik van :() notatie voor het maken van een uitdrukking

Merk op dat :call impliciet wordt gebruikt als het hoofd in bepaalde constructies van uitdrukkingen, bijv 

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

Met de syntaxis :() voor het maken van expressies zal Julia dus proberen automatisch de juiste te gebruiken kop te bepalen. Op dezelfde manier: 

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

Als u niet zeker weet wat u moet gebruiken voor een expressie die u bijvoorbeeld gebruikt, bijvoorbeeld Expr() , kan dit een handig hulpmiddel zijn om tips en ideeën te krijgen over wat u moet gebruiken.

Interpolatie en uitdrukkingen

Het maken van uitdrukkingen vermeldt dat uitdrukkingen nauw verwant zijn aan tekenreeksen. Als zodanig zijn de principes van interpolatie binnen strings ook relevant voor Expressies. In de basisreeksinterpolatie kunnen we bijvoorbeeld iets hebben als: 

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

We gebruiken het $ -teken om de waarde van n in de string in te voegen. We kunnen dezelfde techniek gebruiken met uitdrukkingen. Eg 

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

Vergelijk dit dit: 

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

Met het eerste voorbeeld stellen we dus van tevoren de waarde in van a die zal worden gebruikt op het moment dat de uitdrukking wordt geëvalueerd. Met het tweede voorbeeld zal de Julia-compiler echter alleen kijken naar a om de waarde ervan te vinden op het moment van evaluatie voor onze expressie.

Externe verwijzingen naar uitdrukkingen

Er zijn een aantal nuttige webbronnen die je kennis van uitdrukkingen in Julia verder kunnen helpen. Waaronder:

SO-berichten:



Modified text is an extract of the original Stack Overflow Documentation
Licentie onder CC BY-SA 3.0
Niet aangesloten bij Stack Overflow