Skip to content
This page has been auto-translated and may contain errors.View in English

आउटपुट और इनपुट

docs.scrimba.com

दो उपकरण जिनका उपयोग आप पहली पंक्ति से करेंगे: print() टर्मिनल में मान दिखाता है, input() उपयोगकर्ता से पाठ प्राप्त करता है। वे सरल हैं, लेकिन जानना कि वे कैसे काम करते हैं, शुरुआत में कई आश्चर्य से आपको बचाता है।

print() और input() Python के मानक टर्मिनल I/O फंक्शन हैं। दोनों वो दिखने से कहीं अधिक कॉन्फ़िगर योग्य हैं। print() तर्क स्वीकार करता है जो नियंत्रित करते हैं कि मान कैसे जुड़ते हैं और आउटपुट कहाँ समाप्त होता है। input() हमेशा एक स्ट्रिंग लौटाता है, जो प्रभावित करता है कि आप उपयोगकर्ता से आने वाले हर मान को कैसे संभालते हैं।

पर्दे के पीछे, print() sys.stdout में लिखता है और input() sys.stdin से पढ़ता है (मानक आउटपुट और इनपुट स्ट्रीम जिनसे आपका टर्मिनल जुड़ा है)। दोनों केवल पाठ के साथ काम करते हैं, और आउटपुट डिफ़ॉल्ट रूप से buffered है: Python इसे संक्षेप में रखता है और एक बार में एक चरित्र के बजाय chunks में लिखता है। दो परिणाम वास्तविक प्रोग्राम में महत्वपूर्ण हैं: आउटपुट त्रुटियों से एक अलग स्ट्रीम में जाता है (stdout बनाम stderr), और आप उस बफर को फ्लश करने के लिए बाध्य कर सकते हैं जब आपको आउटपुट तुरंत दिखना हो।

Python आपके कोड को कैसे चलाता है

Python आपके कोड को ऊपर से नीचे तक, एक बार में एक पंक्ति, ठीक उसी क्रम में चलाता है जिस क्रम में आपने इसे लिखा है। कोई जम्पिंग नहीं। आप चीजें जिस क्रम में लिखते हैं वह क्रम है जिसमें वे चलती हैं। हमेशा।

python
city = "New Delhi"
print(city)
print("Population: 32 million")

city को पहले असाइन किया जाता है। पहली print चलती है। दूसरी print चलती है। हर बार, उसी क्रम में।

यह महत्वपूर्ण है क्योंकि आप एक चर का उपयोग करने से पहले उसे असाइन नहीं कर सकते। Python ने इसे अभी तक नहीं देखा है और एक त्रुटि उठाएगा:

python
print(country)   # NameError: country अभी तक परिभाषित नहीं है
country = "India"

इसे ध्यान में रखें जब आपके प्रोग्राम बड़े हों: कोई भी चीज़ जो आप उपयोग करते हैं वह उपयोग करने से पहले परिभाषित होनी चाहिए।

Python sequential execution का उपयोग करता है: प्रत्येक statement का मूल्यांकन तब किया जाता है जब वह सामना किया जाता है, फ़ाइल के माध्यम से एक एकल ऊपर-से-नीचे पास में। पहले पूरी फ़ाइल को स्कैन करना नहीं है। असाइन करने से पहले एक नाम का संदर्भ देने से NameError उठता है, पहले नहीं।

python
city = "New Delhi"
print(city)             # काम करता है: city पहले से ही बाध्य है
print(country)          # NameError: अभी तक असाइन नहीं
country = "India"

नियम: dependencies को उन्हें उपयोग करने वाली पंक्ति से पहले परिभाषित होना चाहिए।

Python आपकी फ़ाइल को एक एकल ऊपर-से-नीचे पास में चलाता है, और यह केवल उस क्षण एक नाम को देखता है जब वह पंक्ति वास्तव में चलती है, न कि जब वह पहली बार फ़ाइल को पढ़ता है। यही कारण है कि एक गायब नाम runtime में एक NameError है (जब पंक्ति निष्पादित होती है) बजाय उस क्षण एक त्रुटि के जब आप बचाते हैं। कोई hoisting नहीं है (जिस तरह JavaScript शांति से var declarations को उनके scope के शीर्ष पर ले जाता है) और कोई forward declarations नहीं (जिस तरह C आपको अभी एक नाम का वादा करने और बाद में इसे परिभाषित करने देता है)। एक नाम तब मौजूद होता है जब वह असाइन किया जाता है, और उससे पहले कोई भी उपयोग उठाता है।

python
print(country)   # runtime पर NameError, syntax error नहीं
country = "India"
JunoPython आपके कोड को कैसे चलाता है Python आपकी फ़ाइल को ऊपर से नीचे तक पढ़ता है, एक बार में एक पंक्ति, जिस क्रम में आपने इसे लिखा है। जाल जो सभी को एक बार फंसाता है: एक नाम को इसका उपयोग करने वाली पंक्ति से पहले मौजूद होना चाहिए, या आपको NameError मिलता है। कोई आगे बढ़ना नहीं, पूरी फ़ाइल पहले पढ़ना नहीं।
JunoPython आपके कोड को कैसे चलाता है ऊपर से नीचे, एक पास, क्रम में। एक नाम को उसे असाइन किया जाना चाहिए इससे पहले कि कोई भी पंक्ति उसे उपयोग करे, अन्यथा यह NameError है उस ठीक पंक्ति पर। फ़ाइल का कोई पूर्व-स्कैन नहीं।
JunoPython आपके कोड को कैसे चलाता है एक ऊपर-से-नीचे पास, नामों को प्रत्येक पंक्ति के चलने पर देखा जाता है। किसी नाम को इसके असाइन होने से पहले उपयोग करें और आपको runtime पर `NameError` मिलता है, syntax error नहीं। Python hoist नहीं करता है और forward declarations नहीं हैं, इसलिए क्रम वास्तव में सब कुछ है।

आउटपुट प्रिंट करना

print() है कि Python आपके साथ कैसे बात करता है। इसे कोई भी मान पास करें और यह उस मान को प्रदर्शित करता है। यह स्वचालित रूप से आपने इसे जो दिया है उसे पाठ में बदल देता है।

print() प्रत्येक तर्क को str() के माध्यम से एक स्ट्रिंग में बदलता है, उन्हें एक विभाजक के साथ जोड़ता है (डिफ़ॉल्ट रूप से एक स्पेस), फिर परिणाम को एक newline के साथ मानक आउटपुट में लिखता है। डिफ़ॉल्ट को समझना optional तर्कों को अधिक predictable बनाता है।

print() की पूरी signature है print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)*objects collector किसी भी संख्या में positional तर्कों को स्वीकार करता है और प्रत्येक पर str() को कॉल करता है। sep और end formatting को नियंत्रित करते हैं; file आउटपुट को किसी भी writable stream में रीडायरेक्ट करता है; flush बफर को तुरंत निकालने के लिए बाध्य करता है।

python
print("Hello")    # Hello
print(42)         # 42
print(3.14)       # 3.14
print(True)       # True

कई मान

आप एक बार में कई मान प्रिंट कर सकते हैं उन्हें commas से अलग करके। Python डिफ़ॉल्ट रूप से उनके बीच एक स्पेस डालता है। विभाजक को sep के साथ बदलें:

कई positional तर्कों को प्रत्येक को अलग से str() के साथ बदला जाता है, फिर sep द्वारा जुड़ा जाता है। डिफ़ॉल्ट sep एक single space है। इसे override करने से आप string concatenation के बिना formatted output produce कर सकते हैं:

print() एक string बनाता नहीं है और लिखता है; यह प्रत्येक तर्क को stream में turn में लिखता है (प्रत्येक पर str() को कॉल करते हुए), sep के साथ और अंत में end। क्योंकि वे writes एक बार में एक locked operation के बजाय होते हैं, दो print() calls एक ही समय पर चलती हैं (विभिन्न threads पर) उनका आउटपुट interleave कर सकते हैं। जब इससे matter हो, एक string बनाएं और इसे एक बार प्रिंट करें। रोज़मर्रा के उपयोग के लिए, sep को override करना अभी भी हाथ से strings को glue करने से बेहतर है:

python
name = "राज"
age = 28
print(name, age)                        # राज 28
print("Name:", name)                    # Name: राज
print("2024", "01", "15", sep="-")     # 2024-01-15
print("a", "b", "c", sep=", ")         # a, b, c

line ending को नियंत्रित करना

प्रत्येक print() call डिफ़ॉल्ट रूप से एक newline के साथ समाप्त होता है, इसलिए अगला आउटपुट एक ताज़ी पंक्ति पर शुरू होता है। end के साथ इसे बदलें। end="" को सेट करने से अगली print same line पर जारी रहती है:

end parameter डिफ़ॉल्ट newline को बदलता है। इसे "" पर सेट करें line break को suppress करने के लिए, " " पर same line पर एक space के साथ रहने के लिए, या किसी अन्य string पर। sep के साथ combined, आप अधिकांश output formats को manually strings बनाए बिना produce कर सकते हैं:

sep और end keyword-only हैं (आप उन्हें नाम से pass करते हैं, जैसे end="", कभी position से नहीं), एक space और एक newline को defaulting करते हुए। end="" एक partial line print करने और अगली call को इसे carry करने देने का मानक तरीका है। Output के लिए जो दिखने की जरूरत है जैसे यह होता है, एक progress indicator या live log की तरह, flush=True जोड़ें ताकि Python तुरंत लिखे बजाय एक newline या अपने buffer के भरने का इंतज़ार करने के।

python
print("Loading", end="")
print("...")
# Loading...

print("one", end=" | ")
print("two", end=" | ")
print("three")
# one | two | three
Junoआउटपुट प्रिंट करनाprint() जो कुछ भी आप इसे देते हैं उसे पाठ में बदलता है और दिखाता है। commas से अलग कई चीजें पास करें और आपको उनके बीच एक स्पेस मिलता है, sep के साथ बदलें। हर print अंत में एक नई पंक्ति पर गिरती है; end="" अगले को same line पर रखता है।
Junoआउटपुट प्रिंट करनाprint() प्रत्येक तर्क पर `str()` चलाता है, उन्हें sep के साथ जोड़ता है (डिफ़ॉल्ट रूप से एक स्पेस), और end के साथ समाप्त करता है (डिफ़ॉल्ट रूप से एक newline)। Output को format करने के लिए किसी को override करें strings को glue किए बिना।
Junoआउटपुट प्रिंट करनाprint() प्रत्येक तर्क को `str()` के माध्यम से लिखता है, बीच में sep और अंत में end के साथ, दोनों keyword-only हैं। एक line को continue करने के लिए end="" तक पहुंचें, और flush=True जब output को तुरंत दिखना है।

f-strings के साथ आउटपुट को format करना

मैसेज बनाने का सबसे साफ तरीका f-strings है। opening quote से पहले f रखें, फिर किसी भी चर या expression को curly braces में लपेटें। Python runtime पर इसे भरता है। आप {} के अंदर कोई भी मान, calculation, या method call रख सकते हैं।

f-strings {} के अंदर किसी भी expression को runtime पर evaluate करते हैं और परिणाम को एक string के रूप में embed करते हैं। value के बाद एक colon एक format spec introduce करता है: decimal places, alignment, और number formatting को नियंत्रित करने के लिए एक compact syntax। वे concatenation की तुलना में तेज़ और अधिक readable हैं, और उन्हें explicit str() calls की आवश्यकता नहीं है।

एक f-string में प्रत्येक {} अंत में format(value, spec) को कॉल करता है, जो मान के अपने __format__ method को देता है (एक dunder, double-underscore method जिसे Python एक मान को format करने के लिए कॉल करता है)। तो कोई भी class यह decide कर सकता है कि यह एक f-string के अंदर कैसा दिखता है __format__ को defining करके। Conversion flags !r, !s, और !a value पर पहले repr(), str(), या ascii() चलाते हैं; !r debugging के लिए याद रखने वाला है, क्योंकि यह एक मान को दिखाता है जैसे आप इसे code में type करते, quotes, escapes और सब कुछ के साथ, नीचे practice में दिखाया गया है।

python
name = "राज"
score = 980

# concatenation: clunky, requires str() for numbers
print("Player: " + name + ", Score: " + str(score))

# f-string: readable, no manual conversion
print(f"Player: {name}, Score: {score}")

आप {} के अंदर कोई भी expression रख सकते हैं: arithmetic, method calls (जैसे .upper(), Strings chapter में पूरी तरह covered), format specs:

python
price = 49.99
tax = 0.2
total = price * (1 + tax)

print(f"Total: {total:.2f}")          # Total: 59.99
print(f"Name: {name.upper()}")        # Name: राज
print(f"2 + 2 = {2 + 2}")             # 2 + 2 = 4

: के बाद format spec नियंत्रित करता है कि मान कैसे प्रदर्शित होता है:

python
ratio = 0.8765
count = 1234567
label = "revenue"

print(f"{ratio:.1%}")       # 87.6%
print(f"{count:,}")         # 1,234,567
print(f"{label:>12}")       # "     revenue"

:.2f का मतलब है "two decimal places"। आप इसका उपयोग लगातार prices और measurements के लिए करेंगे। बाकी सब कुछ तब है जब आपको इसकी आवश्यकता है। मुख्य बात: कुछ भी {} के अंदर जा सकता है, केवल चर नाम नहीं।

:.2f और :.0% अधिकांश formatting needs को cover करते हैं। Alignment specifiers (>, <, ^) एक width के साथ neat tabular output produce करते हैं। सामान्य pattern है {value:[align][width][.precision][type]}। एक बार जब आप parts को recognize करते हैं, कोई भी spec सब कुछ combinations को memorise किए बिना readable है।

एक ही spec विभिन्न types को विभिन्न चीज़ें मतलब कर सकता है, क्योंकि प्रत्येक type खुद को format करता है। f"{'hi':5}" पाठ को दाईं ओर pad करता है (पाठ डिफ़ॉल्ट रूप से बाएं align है) जबकि f"{42:5}" बाएं pad करता है (संख्याएं दाईं ओर align हैं): same :5, opposite result। प्रत्येक built-in type इस format mini-language के लिए अपने नियम carry करता है, और एक custom class अपने को __format__ को defining करके सेट करता है।

Junof-strings के साथ आउटपुट को format करना Opening quote से पहले `f` रखें और कुछ भी `{}` में लपेटें: एक चर, एक sum, यहाँ तक कि एक method call। एक colon formatting जोड़ता है, जैसे :.2f दो decimal places के लिए। `+` के साथ strings को glue करने की तुलना में कितना अधिक साफ।
Junof-strings के साथ आउटपुट को format करनाf"..." किसी भी expression के परिणाम को सीधे string में गिराता है, कोई str() की ज़रूरत नहीं। Colon के बाद format spec आता है: :.2f, :,, :>12 और दोस्त। Concatenation से cleaner और faster।
Junof-strings के साथ आउटपुट को format करना प्रत्येक `{}` मान के अपने `__format__` को कॉल करता है, इसलिए colon के बाद spec मतलब है जो वह type decide करता है। `!r` याद रखने वाला है: यह एक मान को दिखाता है जैसे आप इसे type करेंगे, जो stray whitespace और अन्य invisible junk को make करता है जब आप debugging कर रहे हों तो stand out।

उपयोगकर्ता से इनपुट प्राप्त करना

input() आपके प्रोग्राम को pause करता है और उपयोगकर्ता को कुछ type करने के लिए wait करता है। जो भी वे type करते हैं (और Enter दबाते हैं) return value के रूप में आता है। parentheses में string वह prompt है जो उपयोगकर्ता देखता है।

python
name = input("What's your name? ")
print(f"Hello, {name}!")

input() हमेशा एक string लौटाता है, चाहे उपयोगकर्ता कुछ भी type करे। 42 type करें और आपको "42" मिलता है, संख्या 42 नहीं। इसके साथ arithmetic करने के लिए, explicitly convert करें:

python
age = int(input("How old are you? "))
print(f"In ten years you'll be {age + 10}.")

क्या होगा अगर उपयोगकर्ता कुछ type करे जिसे convert नहीं किया जा सकता? Python एक ValueError उठाता है। इसे properly handle करना Files और exceptions chapter में covered है।

input() standard output में prompt लिखता है, standard input से एक line पढ़ता है, trailing newline को strips करता है, और परिणाम को एक string के रूप में लौटाता है। कोई type inference नहीं है। टर्मिनल से सब कुछ पाठ के रूप में आता है; आप explicit रूप से convert करके आवश्यक type declare करते हैं boundary पर।

python
name = input("What's your name? ")
age = int(input("How old are you? "))

यह pattern (पाठ receive करें, आवश्यक type में convert करें) हर जगह लागू होता है जहां external data आता है। int(), float(), और str() conversion tools हैं। अगर string convert नहीं किया जा सकता, Python ValueError उठाता है, Files और exceptions chapter में covered।

input() एक thin wrapper है: यह sys.stdout (standard output) में prompt लिखता है, इसे flush करता है ताकि prompt program के block होने से पहले दिखे, sys.stdin (standard input) से एक line पढ़ता है, trailing newline को strips करता है, और एक str हाथ में देता है। यह डिज़ाइन से हमेशा str है, क्योंकि Python guess नहीं कर सकता कि "42" को एक integer, एक float, या literal पाठ के रूप में मतलब था। तो आप entry point पर convert करते हैं। यह Python I/O का fundamental shape है: external data पाठ के रूप में आता है, और आपका code entry point पर इसके type को decide करता है।

python
name = input("Enter your name: ")
score = float(input("Enter your score (0.0 to 1.0): "))

print(f"Name:  {name!r}")      # !r any invisible whitespace को reveal करता है
print(f"Score: {score:.1%}")
Junoउपयोगकर्ता से इनपुट प्राप्त करनाinput() आपका prompt दिखाता है, एक line के लिए wait करता है, और हमेशा इसे string के रूप में देता है, भले ही उन्होंने एक संख्या type की हो। संख्या की ज़रूरत है? इसे खुद convert करें int() या float() के साथ जब यह आती है, फिर सही type के साथ जारी रखें।
Junoउपयोगकर्ता से इनपुट प्राप्त करनाinput() हमेशा एक `str` लौटाता है, कोई type inference नहीं। Boundary पर `int()` या `float()` के साथ convert करें, और एक `ValueError` expect करें अगर पाठ parse नहीं होता। वह receive-then-convert pattern हर जगह दिखता है जहां external data होता है।
Junoउपयोगकर्ता से इनपुट प्राप्त करना `input()` से सब कुछ एक `str` है डिज़ाइन से, क्योंकि Python guess नहीं कर सकता कि आपका मतलब क्या था। Entry point पर convert करें और `ValueError` को handle करें जब यह parse नहीं होगा। External data के हर दूसरे स्थान पर same shape।

stderr में लिखना

डिफ़ॉल्ट रूप से, print() standard output में लिखता है: stream जो टर्मिनल में दिखता है और pipes में बहता है। Python के पास standard error भी है, एक अलग stream diagnostics और warnings के लिए। वे टर्मिनल में समान दिखते हैं लेकिन distinct हैं: जब आप script के output को किसी अन्य command में pipe करते हैं, केवल stdout जाता है। Stderr हमेशा टर्मिनल तक पहुंचता है।

stderr में लिखना print() के file argument का उपयोग करता है। इसे sys importing की आवश्यकता है, जो Modules chapter में covered है। अभी के लिए, जानना कि दो streams मौजूद हैं और वे क्यों अलग हैं पर्याप्त है।

व्यवहार में

एक quiz जो user input से खुद को personalize करती है:

python
name = input("What's your name? ")
subject = input("Which subject? ")

print(f"Okay, {name}. Starting your {subject} quiz.")
print("Good luck!")

दोनों inputs strings के रूप में आते हैं और f-strings में सीधे जाते हैं। कोई conversion की ज़रूरत नहीं है क्योंकि आप उन्हें पाठ के रूप में use कर रहे हैं, संख्याओं के रूप में नहीं।

एक temperature converter aligned tabular output के साथ:

python
celsius = float(input("Temperature in Celsius: "))
fahrenheit = celsius * 9 / 5 + 32

print(f"{'Celsius':>12} {'Fahrenheit':>12}")
print(f"{celsius:>12.1f} {fahrenheit:>12.1f}")

float() उपयोगकर्ता से integers और decimals दोनों को handle करता है। >12 spec columns को aligned रखता है regardless of कि संख्याओं में कितने digits हों। 100 और -40 enter करने की कोशिश करें: output दोनों तरीकों से tidy रहता है।

Exactly क्या Python received करता है को surface करने के लिए !r का उपयोग करना, उपयोगी जब output गलत दिखे:

python
name = input("Enter your name: ")
score = float(input("Enter your score (0.0 to 1.0): "))

print(f"Name:   {name!r}")
print(f"Score:  {score!r}")
print()
print(f"Result: {name}: {score:.1%}")

{name} और {name!r} identically display करते हैं जब input clean हो। अंतर तब दिखता है जब trailing spaces या अन्य invisible characters हों। Debugging के दौरान !r की habit में पड़ जाना unexpected values को immediately visible बनाता है।