Julia Language
इनपुट

वाक्य - विन्यास

• पढ़ने के लिए लाइन()
• readlines ()
• readstring (STDIN)
• chomp (एसटीआर)
• खुला (च, फ़ाइल)
• eachline (आईओ)
• readstring (फाइल)
• पढ़ने (फाइल)
• readcsv (फाइल)
• readdlm (फाइल)

पैरामीटर

मानक इनपुट से एक स्ट्रिंग पढ़ना

जूलिया में STDIN स्ट्रीम मानक इनपुट को संदर्भित करता है। यह इंटरएक्टिव कमांड-लाइन प्रोग्राम्स के लिए या तो इनपुट का प्रतिनिधित्व कर सकता है, या प्रोग्राम में रीडायरेक्ट की गई फ़ाइल या पाइपलाइन से इनपुट।

readline फ़ंक्शन, जब कोई तर्क नहीं दिया जाता है, तब तक STDIN से डेटा पढ़ा जाएगा जब तक कि कोई नई लाइन सामने नहीं आती है, या STDIN स्ट्रीम फ़ाइल के अंत स्थिति में प्रवेश करती है। इन दो मामलों को इस बात से अलग किया जा सकता है कि क्या अंतिम चरित्र के रूप में \n चरित्र को पढ़ा गया है:

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

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

अक्सर, इंटरैक्टिव कार्यक्रमों के लिए, हम ईओएफ राज्य के बारे में परवाह नहीं करते हैं, और बस एक स्ट्रिंग चाहते हैं। उदाहरण के लिए, हम उपयोगकर्ता को इनपुट के लिए संकेत दे सकते हैं:

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

हालांकि, यह अतिरिक्त नई सीमा के कारण काफी संतोषजनक नहीं है:

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

एक स्ट्रिंग से एक अनुगामी newline तक निकालने के लिए chomp फ़ंक्शन उपलब्ध है। उदाहरण के लिए:

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

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

इसलिए हम अपने कार्य को chomp बढ़ा सकते हैं ताकि परिणाम अपेक्षित हो:

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

जिसका अधिक वांछनीय परिणाम है:

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

कभी-कभी, हम संभव के रूप में कई पंक्तियों को पढ़ने की इच्छा कर सकते हैं (जब तक कि इनपुट स्ट्रीम अंत-फ़ाइल फ़ाइल स्थिति में प्रवेश नहीं करती है)। readlines फ़ंक्शन उस क्षमता को प्रदान करता है।

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"               

अन्य समय में, हम लाइनों के बारे में बिल्कुल भी परवाह नहीं कर सकते हैं, और बस एक स्ट्रिंग के रूप में अधिक से अधिक पढ़ना चाहते हैं। readstring फ़ंक्शन इसे पूरा करता है:

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] मूल इनपुट का हिस्सा नहीं है; इसे स्पष्टता के लिए जोड़ा गया है।)

ध्यान दें कि readstring को STDIN तर्क पारित किया जाना चाहिए।

स्टैंडर्ड इनपुट से रीडिंग नंबर

मानक इनपुट से संख्याओं को पढ़ना स्ट्रिंग को पढ़ने और संख्याओं के रूप में ऐसे तारों को पार्स करने का एक संयोजन है।

parse फ़ंक्शन का उपयोग वांछित संख्या प्रकार में स्ट्रिंग को पार्स करने के लिए किया जाता है:

julia> parse(Int, "17")
17

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

parse(T, x) द्वारा अपेक्षित प्रारूप के समान है, लेकिन बिल्कुल वैसा ही नहीं है, जैसा कि प्रारूप जूलिया साहित्यकारों से उम्मीद करता है :

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

parse और readline फ़ंक्शंस को readline हमें एक लाइन से एक ही नंबर पढ़ने की अनुमति मिलती है:

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

जो उम्मीद के मुताबिक काम करता है:

julia> asknumber()
Enter a number: 78.3
78.3

फ्लोटिंग-पॉइंट सटीक के बारे में सामान्य कैविट्स लागू होते हैं। ध्यान दें कि parse साथ इस्तेमाल किया जा सकता BigInt और BigFloat हटाने या परिशुद्धता के नुकसान को कम करने के लिए।

कभी-कभी, एक ही पंक्ति से एक से अधिक संख्या पढ़ना उपयोगी होता है। आमतौर पर, लाइन को व्हॉट्सएप के साथ विभाजित किया जा सकता है:

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

जिसका उपयोग निम्नानुसार किया जा सकता है:

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

फ़ाइल से डेटा पढ़ना

स्ट्रिंग्स या बाइट्स पढ़ना

फ़ाइलें open फ़ंक्शन का उपयोग करके पढ़ने के लिए खोली जा सकती हैं, जिन्हें अक्सर ब्लॉक सिंटैक्स के साथ एक साथ उपयोग किया जाता है:

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

मान लीजिए कि myfile मौजूद है और इसकी सामग्री है

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

फिर, यह कोड निम्नलिखित परिणाम देगा:

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

ध्यान दें कि eachline एक आलसी है iterable फ़ाइल की लाइनों पर। प्रदर्शन कारणों से readlines लिए पसंद किया readlines है।

क्योंकि do ब्लॉक वाक्य रचना गुमनाम कार्यों के लिए बस वाक्यात्मक चीनी है, हम नामित करने के लिए कार्य करता है पारित कर सकते हैं 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

कार्यों read और readstring सुविधा तरीकों कि एक फ़ाइल अपने आप खुल जाएगा प्रदान करते हैं:

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

संरचित डेटा पढ़ना

मान लें कि हमारे पास एक CSV फ़ाइल थी , जिसमें निम्न सामग्री थी, file.csv नामक फ़ाइल में:

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

फिर हम इस डेटा को एक Matrix में पढ़ने के लिए readcsv फ़ंक्शन का उपयोग कर सकते हैं:

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      

यदि फ़ाइल को टैब के साथ सीमांकित किया गया file.tsv , तो file.tsv नामक एक फ़ाइल में, तो इसके बजाय readdlm फ़ंक्शन का उपयोग किया जा सकता है, जिसमें delim तर्क '\t' सेट है। अधिक उन्नत कार्यभार को CSV.jl पैकेज का उपयोग करना चाहिए।