Julia Language
espressioni

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


Introduzione alle espressioni

Le espressioni sono un tipo specifico di oggetto in Julia. Puoi pensare a un'espressione come a un pezzo di codice Julia che non è stato ancora valutato (cioè eseguito). Ci sono poi funzioni e operazioni specifiche, come eval() che valuterà l'espressione.

Ad esempio, potremmo scrivere uno script o inserire nell'interprete quanto segue: julia> 1 + 1 2

Un modo per creare un'espressione è usare la sintassi :() . Per esempio: 

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

Ora abbiamo un oggetto di tipo Expr . Essendosi appena formato, non fa nulla, si siede come un qualsiasi altro oggetto fino a quando non viene messo in atto. In questo caso, possiamo valutare quell'espressione usando la eval() : 

julia> eval(MyExpression)
2

Quindi, vediamo che i due seguenti sono equivalenti: 

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

Perché dovremmo passare attraverso la sintassi molto più complicata di eval(:(1+1)) se vogliamo solo scoprire cosa è uguale a 1 + 1? La ragione di base è che possiamo definire un'espressione in un punto del nostro codice, potenzialmente modificarla in seguito, e quindi valutarla in un secondo momento. Questo può potenzialmente aprire nuove potenti funzionalità al programmatore Julia. Le espressioni sono una componente chiave della metaprogrammazione in Julia.

Creazione di espressioni

Esistono diversi metodi che possono essere utilizzati per creare lo stesso tipo di espressione. Le espressioni intro menzionavano la sintassi :() . Forse il miglior punto di partenza, tuttavia è con le stringhe. Ciò aiuta a rivelare alcune delle somiglianze fondamentali tra espressioni e stringhe in Julia.

Crea espressione da stringa

Dalla documentazione di Julia:

Ogni programma Julia inizia la vita come una stringa

In altre parole, qualsiasi script di Julia è semplicemente scritto in un file di testo, che non è altro che una stringa di caratteri. Allo stesso modo, qualsiasi comando di Julia inserito in un interprete è solo una stringa di caratteri. Il ruolo di Julia o di qualsiasi altro linguaggio di programmazione è quindi quello di interpretare e valutare le stringhe di caratteri in modo logico e prevedibile, in modo che le stringhe di caratteri possano essere utilizzate per descrivere ciò che il programmatore vuole che il computer compia.

Quindi, un modo per creare un'espressione è usare la funzione parse() applicata a una stringa. La seguente espressione, una volta valutata, assegnerà il valore di 2 al simbolo x . 

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

Crea espressione usando :() Sintassi 

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

Nota che con questa sintassi, Julia tratterà automaticamente i nomi degli oggetti come riferiti ai simboli. Possiamo vedere questo se guardiamo gli args dell'espressione. (Vedi Campi degli oggetti espressione per ulteriori dettagli sul campo args in un'espressione.) 

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

Crea espressione usando la funzione Expr() 

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

Questa sintassi è basata sulla notazione del prefisso . In altre parole, il primo argomento specificato per la funzione Expr() è la head o il prefisso. I restanti sono gli arguments dell'espressione. La head determina quali operazioni saranno eseguite sugli argomenti.

Per maggiori dettagli su questo, vedere Campi degli oggetti espressione

Quando si utilizza questa sintassi, è importante distinguere tra l'uso di oggetti e simboli per gli oggetti. Ad esempio, nell'esempio sopra, l'espressione assegna il valore di 2 al simbolo :x , un'operazione perfettamente ragionevole. Se usassimo x se stesso in un'espressione come quella, otterremmo il risultato insensato: 

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

Allo stesso modo, se esaminiamo gli args che vediamo: 

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

Pertanto, la funzione Expr() non esegue la stessa trasformazione automatica in simboli come la sintassi :() per la creazione di espressioni.

Crea espressioni multi-linea usando quote...end 

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

Si noti che con quote...end possiamo creare espressioni che contengono altre espressioni nel loro campo args : 

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

Vedi Fields of Expression Objects per ulteriori informazioni su questo args .

Ulteriori informazioni sulla creazione di espressioni

Questo esempio fornisce solo le basi per la creazione di espressioni. Vedi anche, ad esempio, Interpolazione ed espressioni e campi di oggetti espressione per ulteriori informazioni sulla creazione di espressioni più complesse e avanzate.

Campi di oggetti espressione

Come menzionato nelle espressioni Intro to Expressions sono un tipo specifico di oggetto in Julia. In quanto tali, hanno campi. I due campi più usati di un'espressione sono la sua head e le sue args . Ad esempio, considera l'espressione 

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

discusso in Creazione di espressioni . Possiamo vedere la head e gli args come segue: 

julia> MyExpr3.head
:(=)

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

Le espressioni sono basate sulla notazione del prefisso . In quanto tale, la head generalmente specifica l'operazione che deve essere eseguita sugli args . La testa deve essere di tipo Julia Symbol .

Quando un'espressione deve assegnare un valore (quando viene valutato), generalmente utilizza una testa di :(=) . Ovviamente ci sono ovvie variazioni che possono essere impiegate, ad esempio: 

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

: call for expression heads

Un altro head comune per le espressioni è :call . Per esempio 

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

Seguendo le convenzioni della notazione del prefisso, gli operatori vengono valutati da sinistra a destra. Quindi, questa espressione qui significa che chiameremo la funzione che è specificata sul primo elemento di args sugli elementi successivi. Analogamente potremmo avere: 

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

O altre funzioni potenzialmente più interessanti, ad es 

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

Determinazione automatica della head quando si usa :() notazione di creazione di espressioni

Nota che :call è implicitamente usata come la testa in certe costruzioni di espressioni, ad es 

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

Quindi, con la sintassi :() per la creazione di espressioni, Julia cercherà di determinare automaticamente la testa corretta da utilizzare. Allo stesso modo: 

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

Infatti, se non sei sicuro di quale sia la testa giusta da usare per un'espressione che stai formando usando, ad esempio, Expr() questo può essere uno strumento utile per ottenere consigli e idee su cosa usare.

Interpolazione ed espressioni

La creazione di espressioni indica che le espressioni sono strettamente correlate alle stringhe. In quanto tali, i principi di interpolazione all'interno delle stringhe sono rilevanti anche per le espressioni. Per esempio, nell'interpolazione di base delle stringhe, possiamo avere qualcosa di simile: 

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

Usiamo il segno $ per inserire il valore di n nella stringa. Possiamo usare la stessa tecnica con le espressioni. Per esempio 

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

Contrasto questo: 

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

Pertanto, con il primo esempio, impostiamo in anticipo il valore di a che verrà utilizzato nel momento in cui viene valutata l'espressione. Con il secondo esempio, tuttavia, il compilatore Julia guarderà a a per trovare il suo valore al momento della valutazione per la nostra espressione.

Riferimenti esterni sulle espressioni

Ci sono un certo numero di risorse web utili che possono aiutare ulteriormente la tua conoscenza delle espressioni in Julia. Questi includono:

Post SO:



Modified text is an extract of the original Stack Overflow Documentation
Autorizzato sotto CC BY-SA 3.0
Non affiliato con Stack Overflow