Julia Language
Eingang

Syntax

• Zeile lesen()
• readlines ()
• Lesefolge (STDIN)
• chomp (str)
• öffnen (f, Datei)
• Jede Zeile (io)
• Lesezeichenfolge (Datei)
• lesen (Datei)
• readcsv (Datei)
• readdlm (Datei)

Parameter

Ein String aus der Standardeingabe lesen

Der STDIN Stream in Julia bezieht sich auf die Standardeingabe . Dies kann entweder eine Benutzereingabe für interaktive Befehlszeilenprogramme oder eine Eingabe aus einer Datei oder Pipeline darstellen , die in das Programm umgeleitet wurde.

Wenn die readline Funktion keine Argumente STDIN , liest sie Daten aus STDIN bis eine neue Zeile gefunden wird oder der STDIN Stream den Dateiendungstatus erreicht. Diese beiden Fälle unterscheiden sich darin, ob das Zeichen \n als letztes Zeichen gelesen wurde:

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

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

Für interaktive Programme ist uns der EOF-Status oft nicht wichtig, und wir möchten nur eine Zeichenfolge. Zum Beispiel können wir den Benutzer zur Eingabe auffordern:

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

Dies ist jedoch aufgrund des zusätzlichen Newlines nicht ganz zufriedenstellend:

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

Die chomp Funktion ist verfügbar, um bis zu eine nachgestellte Zeile aus einer Zeichenfolge zu entfernen. Zum Beispiel:

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

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

Wir können daher unsere Funktion mit chomp so erweitern, dass das Ergebnis wie erwartet ist:

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

was ein wünschenswerteres Ergebnis hat:

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

Manchmal möchten wir möglicherweise so viele Zeilen wie möglich lesen (bis der Eingabestrom in den Dateiendungszustand wechselt). Die Funktion readlines bietet diese Funktion.

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"               

In anderen Fällen interessieren wir uns vielleicht überhaupt nicht für Zeilen und möchten einfach so viel wie möglich als einzelne Zeichenfolge lesen. Die readstring Funktion readstring dies:

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"

(Das # [END OF INPUT] ist nicht Teil der ursprünglichen Eingabe; es wurde aus Gründen der Übersichtlichkeit hinzugefügt.)

Beachten Sie, dass readstring muss übergeben werden STDIN Argument.

Zahlen aus der Standardeingabe lesen

Das Lesen von Zahlen aus der Standardeingabe ist eine Kombination aus dem Lesen von Zeichenfolgen und dem Parsen solcher Zeichenfolgen als Zahlen.

Die parse - Funktion wird verwendet , um eine Zeichenkette in den gewünschten Anzahl Typen zu analysieren:

julia> parse(Int, "17")
17

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

Das von parse(T, x) erwartete Format ist ähnlich, aber nicht genau dasselbe, wie das Format, das Julia von Zahlenlitern erwartet:

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

Durch die Kombination der parse und readline Funktionen können wir eine einzelne Nummer aus einer Zeile lesen:

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

was wie erwartet funktioniert:

julia> asknumber()
Enter a number: 78.3
78.3

Es gelten die üblichen Vorbehalte bezüglich der Fließkomma-Genauigkeit . Beachten Sie, dass parse kann mit verwendet werden BigInt und BigFloat zu entfernen oder Verlust an Präzision zu minimieren.

Manchmal ist es nützlich, mehrere Nummern aus derselben Zeile zu lesen. In der Regel kann die Zeile mit Leerzeichen geteilt werden:

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

was kann wie folgt verwendet werden:

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

Daten aus einer Datei lesen

Strings oder Bytes lesen

Dateien können zum Lesen mit der open Funktion open werden, die häufig zusammen mit do-Block-Syntax verwendet wird :

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

Angenommen, myfile existiert und sein Inhalt ist

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

Dann würde dieser Code das folgende Ergebnis erzeugen:

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

Beachten Sie, dass eachline faul iterable über die Zeilen der Datei ist. Es wird bevorzugt, readlines aus Leistungsgründen zu readlines .

Da do Block-Syntax für anonyme Funktionen nur syntaktischer Zucker ist, können wir auch benannte Funktionen an open :

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

Die Funktionen read und readstring bieten komfortable Methoden, mit denen eine Datei automatisch geöffnet wird:

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

Strukturierte Daten lesen

Nehmen wir an, wir hätten eine CSV-Datei mit folgendem Inhalt in einer Datei namens file.csv :

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

Dann können wir die readcsv Funktion verwenden, um diese Daten in eine Matrix zu lesen:

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      

Wenn die Datei stattdessen durch Tabulatoren in einer Datei namens file.tsv , kann stattdessen die Funktion readdlm verwendet werden, wobei das Argument delim auf '\t' . Für fortgeschrittenere Workloads sollte das Paket CSV.jl verwendet werden .