Julia Language
Contribution

Syntaxe

• readline ()
• readlines ()
• readstring (STDIN)
• chomp (str)
• ouvrir (f, fichier)
• chaque ligne (io)
• readstring (fichier)
• lire (fichier)
• readcsv (fichier)
• readdlm (fichier)

Paramètres

Lecture d'une chaîne à partir d'une entrée standard

Le flux STDIN dans Julia fait référence à une entrée standard . Cela peut représenter une entrée utilisateur, des programmes de ligne de commande interactifs ou une entrée d'un fichier ou d'un pipeline qui a été redirigé dans le programme.

La fonction readline , lorsqu'elle ne STDIN aucun argument, lira les données de STDIN jusqu'à ce qu'une nouvelle ligne soit rencontrée ou que le flux STDIN passe à l'état de fin de fichier. Ces deux cas peuvent être distingués selon que le caractère \n a été lu comme caractère final:

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

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

Souvent, pour les programmes interactifs, nous ne nous soucions pas de l’état EOF et voulons simplement une chaîne. Par exemple, nous pouvons demander à l'utilisateur de saisir des données:

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

Ce n'est pas tout à fait satisfaisant, cependant, en raison de la nouvelle ligne supplémentaire:

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

La fonction chomp est disponible pour supprimer jusqu'à une nouvelle ligne de fin d'une chaîne. Par exemple:

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

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

Nous pouvons donc augmenter notre fonction avec chomp afin que le résultat soit comme prévu:

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

qui a un résultat plus souhaitable:

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

Parfois, nous pouvons souhaiter lire autant de lignes que possible (jusqu'à ce que le flux d'entrée passe à l'état de fin de fichier). La fonction readlines fournit cette fonctionnalité.

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"               

D'autres fois, nous ne nous soucions pas du tout des lignes et voulons simplement lire autant que possible en une seule chaîne. La fonction readstring accomplit ceci:

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"

(le # [END OF INPUT] ne fait pas partie de l'entrée d'origine, il a été ajouté pour plus de clarté.)

Notez que l' readstring doit être transmis à STDIN .

Lecture de nombres à partir d'une entrée standard

La lecture des nombres à partir d'une entrée standard est une combinaison de lecture de chaînes et d'analyse de chaînes telles que des nombres.

La fonction d' parse est utilisée pour analyser une chaîne dans le type de numéro souhaité:

julia> parse(Int, "17")
17

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

Le format attendu par l' parse(T, x) est similaire, mais pas exactement, au format que Julia attend des littéraux numériques :

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

En combinant les parse et readline fonctions nous permet de lire un seul numéro d'une ligne:

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

qui fonctionne comme prévu:

julia> asknumber()
Enter a number: 78.3
78.3

Les mises en garde habituelles concernant la précision en virgule flottante s'appliquent. Notez que l' parse peut être utilisée avec BigInt et BigFloat pour supprimer ou minimiser la perte de précision.

Parfois, il est utile de lire plusieurs numéros de la même ligne. En règle générale, la ligne peut être fractionnée avec des espaces:

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

qui peut être utilisé comme suit:

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

Lecture de données d'un fichier

Lecture de chaînes ou d'octets

Les fichiers peuvent être ouverts pour la lecture en utilisant la fonction open , qui est souvent utilisée avec la syntaxe de bloc :

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

Supposons que myfile existe et que son contenu soit

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

Ensuite, ce code produirait le résultat suivant:

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

Notez que eachline est un paresseux itérables sur les lignes du fichier. Il est préférable de readlines pour des raisons de performance.

Parce do syntaxe de bloc est simplement du sucre syntaxique pour les fonctions anonymes, nous pouvons également passer des fonctions nommées à l' 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

Les fonctions read et readstring fournissent des méthodes pratiques qui ouvriront automatiquement un fichier:

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

Lecture de données structurées

Supposons que nous ayons un fichier CSV avec le contenu suivant, dans un fichier nommé file.csv :

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

Ensuite, nous pouvons utiliser la fonction readcsv pour lire ces données dans une 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 le fichier était plutôt délimité par des tabulations, dans un fichier nommé file.tsv , la fonction readdlm peut être utilisée à la place, l'argument delim défini sur '\t' . Les charges de travail plus avancées doivent utiliser le package CSV.jl.