Julia Language
Ingresso

Sintassi

• linea di lettura()
• readlines ()
• ReadString (STDIN)
• chomp (str)
• open (f, file)
• eachLine (io)
• ReadString (file)
• lettura (file)
• readcsv (file)
• readdlm (file)

Parametri

Lettura di una stringa da input standard

Lo stream STDIN in Julia fa riferimento allo standard input . Questo può rappresentare l'input dell'utente, per i programmi di riga comandi interattivi o l'input da un file o pipeline che è stato reindirizzato nel programma.

La funzione readline , quando non viene fornito alcun argomento, leggerà i dati da STDIN fino a quando non viene rilevata una nuova riga o il flusso STDIN entra nello stato di fine file. Questi due casi possono essere distinti dal fatto che il carattere \n sia stato letto come carattere finale:

julia> readline()
some stuff
"some stuff\n"

julia> readline()  # Ctrl-D pressed to send EOF signal here
""

Spesso, per i programmi interattivi, non ci interessa lo stato EOF e vogliamo solo una stringa. Ad esempio, potremmo richiedere all'utente di inserire:

function askname()
    print("Enter your name: ")
    readline()
end

Questo non è del tutto soddisfacente, tuttavia, a causa della nuova riga aggiuntiva:

julia> askname()
Enter your name: Julia
"Julia\n"

La funzione chomp è disponibile per rimuovere fino a una riga finale finale da una stringa. Per esempio:

julia> chomp("Hello, World!")
"Hello, World!"

julia> chomp("Hello, World!\n")
"Hello, World!"

Potremmo quindi aumentare la nostra funzione con chomp modo che il risultato sia come previsto:

function askname()
    print("Enter your name: ")
    chomp(readline())
end

che ha un risultato più desiderabile:

julia> askname()
Enter your name: Julia
"Julia"

A volte, potremmo voler leggere quante più righe possibile (finché il flusso di input non entra nello stato di fine del file). La funzione readlines fornisce questa funzionalità.

julia> readlines()  # note Ctrl-D is pressed after the last line
A, B, C, D, E, F, G
H, I, J, K, LMNO, P
Q, R, S
T, U, V
W, X  
Y, Z
6-element Array{String,1}:
 "A, B, C, D, E, F, G\n"
 "H, I, J, K, LMNO, P\n"
 "Q, R, S\n"
 "T, U, V\n"
 "W, X\n"
 "Y, Z\n"

julia> chomp.(readlines())
A, B, C, D, E, F, G
H, I, J, K, LMNO, P
Q, R, S
T, U, V
W, X  
Y, Z
6-element Array{String,1}:
 "A, B, C, D, E, F, G"
 "H, I, J, K, LMNO, P"
 "Q, R, S"            
 "T, U, V"            
 "W, X  "             
 "Y, Z"               

Altre volte, potremmo non interessarci affatto delle linee e semplicemente voler leggere il più possibile una singola stringa. La funzione readstring realizza questo:

julia> readstring(STDIN)
If music be the food of love, play on,
Give me excess of it; that surfeiting,
The appetite may sicken, and so die.  # [END OF INPUT]
"If music be the food of love, play on,\nGive me excess of it; that surfeiting,\nThe appetite may sicken, and so die.\n"

(il # [END OF INPUT] non fa parte dell'input originale, è stato aggiunto per chiarezza.)

Si noti che il readstring deve essere passato all'argomento STDIN .

Lettura di numeri da input standard

La lettura dei numeri dall'input standard è una combinazione di stringhe di lettura e l'analisi di tali stringhe come numeri.

La funzione di parse viene utilizzata per analizzare una stringa nel tipo di numero desiderato:

julia> parse(Int, "17")
17

julia> parse(Float32, "-3e6")
-3.0f6

Il formato previsto da parse(T, x) è simile a, ma non esattamente lo stesso, del formato che Julia si aspetta dai numeri letterali :

julia> -00000023
-23

julia> parse(Int, "-00000023")
-23

julia> 0x23 |> Int
35

julia> parse(Int, "0x23")
35

julia> 1_000_000
1000000

julia> parse(Int, "1_000_000")
ERROR: ArgumentError: invalid base 10 digit '_' in "1_000_000"
 in tryparse_internal(::Type{Int64}, ::String, ::Int64, ::Int64, ::Int64, ::Bool) at ./parse.jl:88
 in parse(::Type{Int64}, ::String) at ./parse.jl:152

La combinazione delle funzioni di parse e readline ci consente di leggere un singolo numero da una riga:

function asknumber()
    print("Enter a number: ")
    parse(Float64, readline())
end

che funziona come previsto:

julia> asknumber()
Enter a number: 78.3
78.3

Si applicano i soliti avvertimenti sulla precisione in virgola mobile . Nota che l' parse può essere utilizzata con BigInt e BigFloat per rimuovere o ridurre al minimo la perdita di precisione.

A volte, è utile leggere più di un numero dalla stessa riga. In genere, la riga può essere divisa con spazi:

function askints()
    print("Enter some integers, separated by spaces: ")
    [parse(Int, x) for x in split(readline())]
end

che può essere usato come segue:

julia> askints()
Enter some integers, separated by spaces: 1 2 3 4
4-element Array{Int64,1}:
 1
 2
 3
 4

Lettura dei dati da un file

Lettura di stringhe o byte

I file possono essere aperti per la lettura utilizzando la funzione open , che viene spesso utilizzata insieme alla sintassi del blocco :

open("myfile") do f
    for (i, line) in enumerate(eachline(f))
        print("Line $i: $line")
    end
end

Supponiamo che myfile esista e che il suo contenuto sia

What's in a name? That which we call a rose
By any other name would smell as sweet.

Quindi, questo codice produrrebbe il seguente risultato:

Line 1: What's in a name? That which we call a rose
Line 2: By any other name would smell as sweet.

Nota che eachline è un pigro iterabile sulle linee del file. Si preferisce la readlines per motivi di prestazioni.

Perché do bloccare la sintassi è solo zucchero sintattico per le funzioni anonime, possiamo passare le funzioni di chiamata open anche:

julia> open(readstring, "myfile")
"What's in a name? That which we call a rose\nBy any other name would smell as sweet.\n"

julia> open(read, "myfile")
84-element Array{UInt8,1}:
 0x57
 0x68
 0x61
 0x74
 0x27
 0x73
 0x20
 0x69
 0x6e
 0x20
    ⋮
 0x73
 0x20
 0x73
 0x77
 0x65
 0x65
 0x74
 0x2e
 0x0a

Le funzioni read e readstring forniscono metodi convenienti che apriranno automaticamente un file:

julia> readstring("myfile")
"What's in a name? That which we call a rose\nBy any other name would smell as sweet.\n"

Leggere i dati strutturati

Supponiamo di avere un file CSV con i seguenti contenuti, in un file denominato file.csv :

Make,Model,Price
Foo,2015A,8000
Foo,2015B,14000
Foo,2016A,10000
Foo,2016B,16000
Bar,2016Q,20000

Quindi potremmo usare la funzione readcsv per leggere questi dati in una Matrix :

julia> readcsv("file.csv")
6×3 Array{Any,2}:
 "Make"  "Model"       "Price"
 "Foo"   "2015A"   8000       
 "Foo"   "2015B"  14000       
 "Foo"   "2016A"  10000       
 "Foo"   "2016B"  16000       
 "Bar"   "2016Q"  20000      

Se invece il file era delimitato da tabulazioni, in un file denominato file.tsv , è possibile utilizzare la funzione readdlm , con l'argomento delim impostato su '\t' . Carichi di lavoro più avanzati dovrebbero utilizzare il pacchetto CSV.jl.