Julia Language
Wejście

Składnia

• Czytaj linię()
• readlines ()
• ciąg znaków (STDIN)
• chomp (str)
• otwórz (f, plik)
• eachline (io)
• ciąg do odczytu (plik)
• przeczytaj (plik)
• readcsv (plik)
• readdlm (plik)

Parametry

Odczytywanie ciągu ze standardowego wejścia

Strumień STDIN w Julii odnosi się do standardowego wejścia . Może to reprezentować dane wejściowe użytkownika dla interaktywnych programów wiersza polecenia lub dane wejściowe z pliku lub potoku przekierowanego do programu.

Funkcja readline , jeśli nie zostanie podana żaden argument, odczyta dane ze STDIN dopóki nie zostanie napotkany nowy wiersz lub strumień STDIN przejdzie w stan końca pliku. Te dwa przypadki można rozróżnić po tym, czy znak \n został odczytany jako znak końcowy:

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

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

Często w przypadku programów interaktywnych nie dbamy o stan EOF i chcemy tylko napisu. Na przykład możemy poprosić użytkownika o podanie:

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

Nie jest to jednak do końca satysfakcjonujące z powodu dodatkowej nowej linii:

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

Dostępna jest funkcja chomp aby usunąć maksymalnie jeden znak nowej linii z łańcucha. Na przykład:

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

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

Możemy zatem rozszerzyć naszą funkcję o chomp aby wynik był chomp z oczekiwaniami:

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

co ma bardziej pożądany wynik:

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

Czasami możemy chcieć odczytać jak najwięcej wierszy (dopóki strumień wejściowy nie wejdzie w stan końca pliku). Funkcja readlines zapewnia taką możliwość.

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"               

Innym razem możemy w ogóle nie przejmować się liniami i po prostu chcemy odczytać jak najwięcej pojedynczego łańcucha. Funkcja readstring osiąga to:

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] nie jest częścią oryginalnego wejścia; zostało dodane dla zachowania przejrzystości).

Zauważ, że readstring musi zostać przekazany argumentowi STDIN .

Odczytywanie liczb ze standardowego wejścia

Odczytywanie liczb ze standardowego wejścia jest kombinacją odczytywania ciągów i parsowania takich ciągów jak liczby.

Funkcja parse służy do parsowania łańcucha na żądany typ liczby:

julia> parse(Int, "17")
17

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

Format oczekiwany przez parse(T, x) jest podobny, ale nie dokładnie taki sam, jak format Julia oczekuje od literałów liczbowych :

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

Łącząc parse i readline funkcji pozwala nam odczytać jeden numer z linii:

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

który działa zgodnie z oczekiwaniami:

julia> asknumber()
Enter a number: 78.3
78.3

Obowiązują zwykłe zastrzeżenia dotyczące precyzji zmiennoprzecinkowej . Pamiętaj, że parse można używać z BigInt i BigFloat celu usunięcia lub zminimalizowania utraty precyzji.

Czasami przydatne jest odczytanie więcej niż jednej liczby z tej samej linii. Zazwyczaj linię można podzielić za pomocą białych znaków:

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

które mogą być używane w następujący sposób:

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

Odczytywanie danych z pliku

Czytanie ciągów lub bajtów

Pliki można otwierać do odczytu za pomocą funkcji open , która jest często używana razem ze składnią do block :

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

Załóżmy, że myfile istnieje i jego zawartość

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

Następnie ten kod wygeneruje następujący wynik:

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

Zauważ, że eachline jest leniwy iterable ciągu linii pliku. Preferowane jest readlines ze względu na wydajność.

Ponieważ składnia do block jest tylko składniowym cukrem dla funkcji anonimowych, możemy przekazać nazwane funkcje również w celu 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

Funkcje read i readstring zapewniają metody wygody, które automatycznie otwierają plik:

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

Odczytywanie danych strukturalnych

Załóżmy, że mamy plik CSV o następującej treści, w pliku o nazwie file.csv :

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

Następnie możemy użyć funkcji readcsv do odczytania tych danych do 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      

Jeśli zamiast tego plik jest rozdzielany tabulatorami, w pliku o nazwie file.tsv , można zamiast tego readdlm funkcji readdlm , z argumentem delim ustawionym na '\t' . Bardziej zaawansowane obciążenia powinny korzystać z pakietu CSV.jl.