Julia Language
Invoer

Syntaxis

• Lees regel()
• readlines ()
• readstring (STDIN)
• chomp (str)
• open (f, bestand)
• eachline (io)
• readstring (file)
• read (file)
• readcsv (file)
• readdlm (file)

parameters

Een string uit standaardinvoer lezen

De STDIN stream in Julia verwijst naar standaardinvoer . Dit kan gebruikersinvoer zijn, voor interactieve opdrachtregelprogramma's, of invoer uit een bestand of pijplijn die is doorgestuurd naar het programma.

De readline functie readline , als er geen argumenten worden gegeven, gegevens van STDIN tot een nieuwe regel wordt gevonden of de STDIN stream de status van het einde van het bestand ingaat. Deze twee gevallen kunnen worden onderscheiden door of het \n teken als het laatste teken is gelezen:

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

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

Vaak geven we voor interactieve programma's niet om de EOF-status en willen we gewoon een string. We kunnen de gebruiker bijvoorbeeld om invoer vragen:

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

Dit is echter niet helemaal bevredigend vanwege de extra nieuwe regel:

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

De chomp functie is beschikbaar om maximaal één volglijn van een string te verwijderen. Bijvoorbeeld:

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

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

We kunnen onze functie daarom uitbreiden met chomp zodat het resultaat is zoals verwacht:

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

wat een meer wenselijk resultaat heeft:

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

Soms willen we zoveel mogelijk regels lezen (totdat de invoerstroom de status van het einde van het bestand bereikt). De functie readlines biedt die mogelijkheid.

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"               

Op andere momenten geven we misschien helemaal niets om lijnen en willen we gewoon zoveel mogelijk lezen als een enkele string. De readstring functie bereikt dit:

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"

(het # [END OF INPUT] maakt geen deel uit van de oorspronkelijke invoer; het is toegevoegd voor de duidelijkheid.)

Merk op dat readstring moet worden doorgegeven aan het STDIN argument.

Getallen lezen van standaardinvoer

Getallen lezen van standaardinvoer is een combinatie van tekenreeksen lezen en tekenreeksen ontleden als getallen.

De parse wordt gebruikt om een string in het gewenste nummertype te ontleden:

julia> parse(Int, "17")
17

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

Het door parse(T, x) verwachte formaat parse(T, x) is vergelijkbaar met, maar niet exact hetzelfde, als het formaat dat Julia verwacht van letterlijke getallen :

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

Door de functies parse en lezen te readline , kunnen we een enkel nummer van een regel lezen:

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

die werkt zoals verwacht:

julia> asknumber()
Enter a number: 78.3
78.3

De gebruikelijke kanttekeningen bij drijvende-komma-precisie zijn van toepassing. Merk op dat parse kan worden gebruikt met BigInt en BigFloat om verlies van precisie te verwijderen of te minimaliseren.

Soms is het handig om meer dan één nummer van dezelfde regel te lezen. Doorgaans kan de regel met witruimte worden gesplitst:

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

die als volgt kan worden gebruikt:

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

Gegevens uit een bestand lezen

Tekenreeksen of bytes lezen

Bestanden kunnen worden geopend voor lezen met behulp van de open functie, die vaak wordt gebruikt in combinatie met do block-syntaxis :

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

Stel dat myfile bestaat en de inhoud ervan is

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

Deze code zou dan het volgende resultaat opleveren:

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

Merk op dat elke eachline een luie iterabele is over de regels van het bestand. Het verdient de voorkeur om readlines te readlines om prestatieredenen.

Omdat do bloksyntax is gewoon syntactische suiker voor anonieme functie, kunnen we passeren vernoemd functies te open ook:

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

De functies read en readstring bieden handige methoden die een bestand automatisch openen:

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

Gestructureerde gegevens lezen

Stel dat we een CSV-bestand met de volgende inhoud hadden in een bestand met de naam file.csv :

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

Dan kunnen we de readcsv functie gebruiken om deze gegevens in een Matrix te lezen:

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      

Als het bestand in plaats daarvan met tabs is gescheiden, in een bestand met de naam file.tsv , kan in plaats daarvan de functie readdlm worden gebruikt, met het argument delim ingesteld op '\t' . Meer geavanceerde workloads moeten het CSV.jl- pakket gebruiken .