Julia Language
Inmatning

Syntax

• readline ()
• readlines ()
• readstring (STDIN)
• chomp (str)
• öppen (f, fil)
• eachline (io)
• readstring (fil)
• Läs (fil)
• readcsv (fil)
• readdlm (fil)

parametrar

Läsa en sträng från standardinmatning

STDIN strömmen i Julia hänvisar till standardinmatning . Detta kan representera antingen användarinmatning, för interaktiva kommandoradsprogram, eller inmatning från en fil eller pipeline som har omdirigerats till programmet.

readline , när det inte anges några argument, kommer att läsa data från STDIN tills en ny linje uppstår, eller STDIN strömmen går in i slutet av filtillståndet. Dessa två fall kan särskiljas genom om tecknet \n har lästs som det sista tecknet:

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

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

För interaktiva program bryr vi oss inte om EOF-tillståndet och vill bara ha en sträng. Vi kan till exempel be användaren om inmatning:

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

Detta är dock inte helt tillfredsställande på grund av den nya nylinjen:

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

chomp är tillgänglig för att ta bort upp till en efterföljande ny linje från en sträng. Till exempel:

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

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

Vi kan därför förstärka vår funktion med chomp så att resultatet blir som förväntat:

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

vilket har ett mer önskvärt resultat:

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

Ibland kanske vi vill läsa så många rader som möjligt (tills ingångsströmmen går in i slutet av filtillståndet). Funktionen readlines ger den möjligheten.

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"               

Andra gånger kanske vi inte bryr oss om linjer alls och vill bara läsa så mycket som möjligt som en enda sträng. readstring åstadkommer detta:

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"

( # [END OF INPUT] är inte en del av den ursprungliga inmatningen; den har lagts till för tydlighetens skull.)

Observera att readstring måste passera STDIN argumentet.

Läser nummer från standardinmatning

Läsa siffror från standardinmatning är en kombination av lässträngar och analysera strängar som siffror.

parse används för att analysera en sträng till önskad nummertyp:

julia> parse(Int, "17")
17

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

Formatet som förväntas av parse(T, x) liknar, men inte exakt samma, som det format Julia förväntar sig från antalet bokstavliga :

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

Genom att kombinera parse och readline funktionerna kan vi läsa ett enda nummer från en rad:

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

som fungerar som förväntat:

julia> asknumber()
Enter a number: 78.3
78.3

De vanliga förbehållen om flytpunktsprecision gäller. Observera att parse kan användas med BigInt och BigFloat att ta bort eller minimera förlust av precision.

Ibland är det bra att läsa mer än ett nummer från samma rad. Vanligtvis kan linjen delas med blanksteg:

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

som kan användas enligt följande:

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

Läsa data från en fil

Läser strängar eller byte

Filer kan öppnas för läsning med hjälp av den open funktionen, som ofta används tillsammans med do block-syntax :

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

Anta att myfile finns och dess innehåll är

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

Sedan skulle denna kod ge följande resultat:

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

Observera att eachline är en lat iterable över filens rader. Det är att föredra att readlines av prestandaskäl.

Eftersom do blocket syntax är bara syntaktiskt socker för anonyma funktioner kan vi passerar namnges funktioner för att open också:

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

Funktionerna read och readstring ger readstring som öppnar en fil automatiskt:

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

Läser strukturerade data

Anta att vi hade en CSV-fil med följande innehåll, i en fil med namnet file.csv :

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

Då kan vi använda readcsv funktionen för att läsa dessa data i en 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      

Om filen istället avgränsades med flikar, i en fil med namnet file.tsv , kan readdlm funktionen användas istället, med delim inställt på '\t' . Mer avancerade arbetsbelastningar bör använda CSV.jl- paketet .