Python Language
मूल इनपुट और आउटपुट

इनपुट का उपयोग करना () और raw_input ()

foo = raw_input("Put a message here that asks the user for input")

foo = input("Put a message here that asks the user for input")

प्रिंट फ़ंक्शन का उपयोग करना

print("This string will be displayed in the output")
# This string will be displayed in the output

print("You can print \n escape characters too.")
# You can print escape characters too.

print "This string will be displayed in the output"
# This string will be displayed in the output

print "You can print \n escape characters too."
# You can print escape characters too.

नंबर के लिए उपयोगकर्ता को संकेत देने का कार्य

def input_number(msg, err_msg=None):
    while True:
        try:
            return float(raw_input(msg))
        except ValueError:
            if err_msg is not None:
                print(err_msg)


def input_number(msg, err_msg=None):
    while True:
        try:
            return float(input(msg))
        except ValueError:
            if err_msg is not None:
                print(err_msg)

और इसका उपयोग करने के लिए:

user_number = input_number("input a number: ", "that's not a number!")

या, यदि आप "त्रुटि संदेश" नहीं चाहते हैं:

user_number = input_number("input a number: ")

अंत में एक newline के बिना एक स्ट्रिंग मुद्रण

print "Hello,",
print "World!"
# Hello, World!

print("Hello, ", end="\n")
print("World!")
# Hello, 
# World!

print("Hello, ", end="")
print("World!")
# Hello, World!

print("Hello, ", end="<br>")
print("World!")
# Hello, <br>World!

print("Hello, ", end="BREAK")
print("World!")
# Hello, BREAKWorld!

यदि आप आउटपुट पर अधिक नियंत्रण चाहते हैं, तो आप sys.stdout.write उपयोग कर सकते हैं:

import sys

sys.stdout.write("Hello, ")
sys.stdout.write("World!")
# Hello, World!

स्टड से पढ़ें

पायथन कार्यक्रम यूनिक्स पाइपलाइनों से पढ़ सकते हैं। यहाँ एक सरल उदाहरण है कि stdin से कैसे पढ़ें:

import sys

for line in sys.stdin:
    print(line)

ध्यान रहे कि sys.stdin एक स्ट्रीम है। इसका मतलब यह है कि फॉर-लूप केवल तब समाप्त होगा जब धारा समाप्त हो गई हो।

अब आप अपने अजगर प्रोग्राम में किसी अन्य प्रोग्राम के आउटपुट को निम्नानुसार पाइप कर सकते हैं:

$ cat myfile | python myprogram.py

इस उदाहरण में cat myfile किसी भी यूनिक्स कमांड कि आउटपुट से हो सकता है stdout ।

वैकल्पिक रूप से, fileinput मॉड्यूल का उपयोग करने से काम आ सकता है:

import fileinput
for line in fileinput.input():
    process(line)

एक फ़ाइल से इनपुट

इनपुट को फाइलों से भी पढ़ा जा सकता है। बिल्ट-इन फंक्शन open का उपयोग करके फाइलें खोली जा सकती open । with <command> as <name> सिंटैक्स (जिसे 'संदर्भ प्रबंधक' कहा जाता है) का उपयोग करना, open का उपयोग करना और फ़ाइल को आसान बनाना आसान बनाता है:

with open('somefile.txt', 'r') as fileobj:
    # write code here using fileobj

यह सुनिश्चित करता है कि जब कोड निष्पादन ब्लॉक हो जाता है तो फ़ाइल स्वचालित रूप से बंद हो जाती है।

फाइलें विभिन्न मोड में खोली जा सकती हैं। उपरोक्त उदाहरण में फ़ाइल केवल-पढ़ने के लिए खोली गई है। केवल पढ़ने के लिए एक मौजूदा फ़ाइल खोलने के लिए r उपयोग करें। यदि आप उस फाइल को पढ़ना चाहते हैं तो बाइट्स rb उपयोग करते हैं। मौजूदा फ़ाइल में डेटा जोड़ने के लिए a उपयोग करें। एक फ़ाइल बनाने या उसी नाम की किसी भी मौजूदा फ़ाइल को अधिलेखित करने के लिए w का उपयोग करें। आप पढ़ने और लिखने दोनों के लिए फ़ाइल खोलने के लिए r+ का उपयोग कर सकते हैं। open() का पहला तर्क open() फ़ाइल नाम है, दूसरा मोड है। यदि मोड को खाली छोड़ दिया जाता है, तो यह r डिफ़ॉल्ट होगा।

# let's create an example file:
with open('shoppinglist.txt', 'w') as fileobj:
    fileobj.write('tomato\npasta\ngarlic')

with open('shoppinglist.txt', 'r') as fileobj:
    # this method makes a list where each line 
    # of the file is an element in the list
    lines = fileobj.readlines()

print(lines)
# ['tomato\n', 'pasta\n', 'garlic']

with open('shoppinglist.txt', 'r') as fileobj:
    # here we read the whole content into one string:
    content = fileobj.read()
    # get a list of lines, just like int the previous example:
    lines = content.split('\n')

print(lines)
# ['tomato', 'pasta', 'garlic']

यदि फ़ाइल का आकार छोटा है, तो मेमोरी में संपूर्ण फ़ाइल सामग्री को पढ़ना सुरक्षित है। यदि फ़ाइल बहुत बड़ी है, तो लाइन-बाय-लाइन या विखंडू पढ़ना अक्सर बेहतर होता है, और उसी लूप में इनपुट को संसाधित करें। ऐसा करने के लिए:

with open('shoppinglist.txt', 'r') as fileobj:
    # this method reads line by line:
    lines = []
    for line in fileobj:
        lines.append(line.strip())

फ़ाइलों को पढ़ते समय, ऑपरेटिंग सिस्टम-विशिष्ट लाइन-ब्रेक पात्रों से अवगत रहें। यद्यपि for line in fileobj स्वचालित रूप से उन्हें स्ट्रिप्स बंद कर दिया जाता है, यह हमेशा पढ़ा गया लाइनों पर कॉल strip() को सुरक्षित करता है, जैसा कि ऊपर दिखाया गया है।

खोली गई फ़ाइलें (उपरोक्त उदाहरणों में fileobj ) हमेशा फ़ाइल में एक विशिष्ट स्थान को इंगित करती हैं। जब वे पहली बार फ़ाइल हैंडल पॉइंट्स को फ़ाइल की शुरुआत में खोलते हैं, जो कि स्थिति 0 । फ़ाइल हैंडल यह tell सकता है कि यह वर्तमान स्थिति है:

fileobj = open('shoppinglist.txt', 'r')
pos = fileobj.tell()
print('We are at %u.' % pos) # We are at 0.

सभी सामग्री पढ़ने पर, फ़ाइल हैंडलर की स्थिति फ़ाइल के अंत में बताई जाएगी:

content = fileobj.read()
end = fileobj.tell()
print('This file was %u characters long.' % end)
# This file was 22 characters long.
fileobj.close()

फ़ाइल हैंडलर स्थिति को जो कुछ भी आवश्यक है सेट किया जा सकता है:

fileobj = open('shoppinglist.txt', 'r')
fileobj.seek(7)
pos = fileobj.tell()
print('We are at character #%u.' % pos)

आप दिए गए कॉल के दौरान फ़ाइल सामग्री से किसी भी लम्बाई को पढ़ सकते हैं। ऐसा करने के लिए read() लिए एक तर्क पास करें। जब read() को बिना किसी तर्क के बुलाया जाता है, तो यह फ़ाइल के अंत तक पढ़ा जाएगा। यदि आप एक तर्क पास करते हैं तो यह उस मोड या rb और r आधार पर बाइट्स या वर्णों की संख्या को पढ़ेगा:

# reads the next 4 characters 
# starting at the current position
next4 = fileobj.read(4)
# what we got?
print(next4) # 'cucu'
# where we are now?
pos = fileobj.tell()
print('We are at %u.' % pos) # We are at 11, as we was at 7, and read 4 chars.

fileobj.close()

वर्ण और बाइट के बीच अंतर प्रदर्शित करने के लिए:

with open('shoppinglist.txt', 'r') as fileobj:
    print(type(fileobj.read())) # <class 'str'>

with open('shoppinglist.txt', 'rb') as fileobj:
    print(type(fileobj.read())) # <class 'bytes'>