Julia Language
Entrada

Sintaxis

• readline ()
• líneas de lectura ()
• lectura (STDIN)
• chomp (str)
• abrir (f, archivo)
• cada linea (io)
• Lectura (archivo)
• leer (archivo)
• readcsv (archivo)
• readdlm (archivo)

Parámetros

Leyendo una cadena de entrada estándar

El flujo STDIN en Julia se refiere a la entrada estándar . Esto puede representar la entrada del usuario, para programas de línea de comandos interactivos, o la entrada de un archivo o canalización que se ha redirigido al programa.

La función readline , cuando no se proporciona ningún argumento, leerá los datos de STDIN hasta que se encuentre una nueva línea, o la secuencia STDIN ingrese al estado de fin de archivo. Estos dos casos se pueden distinguir por si el carácter \n ha sido leído como el carácter final:

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

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

A menudo, para los programas interactivos, no nos importa el estado EOF, y solo queremos una cadena. Por ejemplo, podemos pedirle al usuario que ingrese información:

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

Esto no es del todo satisfactorio, sin embargo, debido a la nueva línea adicional:

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

La función chomp está disponible para eliminar hasta una nueva línea final de una cadena. Por ejemplo:

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

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

Por lo tanto, podemos aumentar nuestra función con chomp para que el resultado sea el esperado:

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

que tiene un resultado más deseable:

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

A veces, es posible que deseamos leer tantas líneas como sea posible (hasta que la secuencia de entrada ingrese al estado de fin de archivo). La función readlines proporciona esa capacidad.

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"               

Otras veces, es posible que no nos interesen las líneas en absoluto, y simplemente queremos leer tanto como sea posible como una sola cadena. La función de readstring realiza esto:

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"

(El # [END OF INPUT] no es parte de la entrada original; se ha agregado para mayor claridad.)

Tenga en cuenta que la readstring debe pasar el argumento STDIN .

Lectura de números de entrada estándar

Leer números de una entrada estándar es una combinación de leer cadenas y analizar cadenas como números.

La función de parse se utiliza para analizar una cadena en el tipo de número deseado:

julia> parse(Int, "17")
17

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

El formato esperado por el parse(T, x) es similar, pero no exactamente el mismo, que el formato que Julia espera de los literales numéricos :

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 combinación de las funciones parse y readline nos permite leer un solo número desde una línea:

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

que funciona como se espera:

julia> asknumber()
Enter a number: 78.3
78.3

Se aplican las advertencias habituales sobre la precisión de punto flotante . Tenga en cuenta que el parse se puede usar con BigInt y BigFloat para eliminar o minimizar la pérdida de precisión.

A veces, es útil leer más de un número de la misma línea. Normalmente, la línea se puede dividir con espacios en blanco:

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

que se puede utilizar de la siguiente manera:

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

Leer datos de un archivo

Leyendo cadenas o bytes

Los archivos se pueden abrir para leer usando la función de open , que a menudo se usa junto con la sintaxis de bloque do :

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

Supongamos que myfile existe y sus contenidos son

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

Entonces, este código produciría el siguiente resultado:

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

Tenga en cuenta que eachline es un iterable perezoso sobre las líneas del archivo. Se prefiere a las readlines de readlines por razones de rendimiento.

Debido a do sintaxis de bloque es solo azúcar sintáctica para funciones anónimas, también podemos pasar funciones con nombre para 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

Las funciones de read y readstring read proporcionan métodos convenientes que abrirán un archivo automáticamente:

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

Lectura de datos estructurados

Supongamos que tenemos un archivo CSV con el siguiente contenido, en un archivo llamado file.csv :

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

Entonces podemos usar la función readcsv para leer estos datos en 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      

Si el archivo se delimitó en su lugar con pestañas, en un archivo llamado file.tsv , entonces se puede usar la función readdlm su lugar, con el argumento delim establecido en '\t' . Las cargas de trabajo más avanzadas deberían usar el paquete CSV.jl.