python - आप पायथन में stdin से कैसे पढ़ते हैं?




(13)

आप पायथन में stdin से कैसे पढ़ते हैं?

मैं कोड कोड गोल्फ चुनौतियों में से कुछ करने की कोशिश कर रहा हूं, लेकिन उन्हें सभी को स्टडीन से इनपुट की आवश्यकता होती है। मैं इसे पायथन में कैसे प्राप्त करूं?

आप उपयोग कर सकते हैं:

  • sys.stdin - एक फ़ाइल जैसी वस्तु - सबकुछ पढ़ने के लिए sys.stdin.read() को कॉल करें।
  • input(prompt) - आउटपुट के लिए इसे एक वैकल्पिक प्रॉम्प्ट पास करें, यह स्ट्रडिन से पहले न्यूलाइन तक पढ़ता है, जो इसे स्ट्रिप्स करता है। इनपुट के अंत में यह EOFError उठाता है, आपको अधिक लाइनों के लिए बार-बार ऐसा करना होगा। (शायद गोल्फिंग के लिए अच्छा नहीं है।) पायथन 2 में, यह rawinput(prompt)
  • open(0).read() - पायथन 3 में open फ़ाइल डिस्क्रिप्टर (ऑपरेटिंग सिस्टम आईओ संसाधनों का प्रतिनिधित्व करने वाले पूर्णांक) स्वीकार करते हैं, और 0 stdin का वर्णनकर्ता है। यह sys.stdin जैसी फ़ाइल जैसी ऑब्जेक्ट sys.stdin - शायद sys.stdin लिए आपकी सबसे अच्छी शर्त।
  • open('/dev/stdin').read() - open(0) समान, पायथन 2 और 3 पर काम करता है, लेकिन विंडोज़ (या यहां तक ​​कि सिगविन) पर भी नहीं।
  • fileinput.input() - fileinput.input() sys.argv[1:] , या stdin में सूचीबद्ध सभी फ़ाइलों में लाइनों पर एक पुनरावर्तक देता है अगर नहीं दिया जाता है। ''.join(fileinput.input()) जैसे प्रयोग करें।

पाठ्यक्रम और क्रमशः दोनों sys और fileinput आयात किया जाना चाहिए।

पाइथन 2 और 3, विंडोज़, यूनिक्स के साथ संगत त्वरित sys.stdin उदाहरण

आपको sys.stdin से read की जरूरत है, उदाहरण के लिए, यदि आप stdin पर डेटा पाइप करते हैं:

$ echo foo | python -c "import sys; print(sys.stdin.read())"
foo

फ़ाइल उदाहरण

मान लें कि आपके पास एक फ़ाइल है, inputs.txt , हम उस फ़ाइल को स्वीकार कर सकते हैं और उसे वापस लिख सकते हैं:

python -c "import sys; sys.stdout.write(sys.stdin.read())" < inputs.txt

लंबा जवाब

यहां दो विधियों, raw_input फ़ंक्शन, input (पायथन 2 में raw_input का उपयोग करें), और sys.stdin का उपयोग करके एक पूर्ण, आसानी से प्रतिकृति डेमो है। डेटा असम्बद्ध है, इसलिए प्रसंस्करण एक गैर-ऑपरेशन है।

आरंभ करने के लिए, आइए इनपुट के लिए एक फाइल बनाएं:

$ python -c "print('foo\nbar\nbaz')" > inputs.txt

और कोड का उपयोग करके हम पहले ही देख चुके हैं, हम जांच सकते हैं कि हमने फ़ाइल बनाई है:

$ python -c "import sys; sys.stdout.write(sys.stdin.read())" < inputs.txt 
foo
bar
baz

Python 3 से sys.stdin.read पर सहायता यहां sys.stdin.read गई है:

read(size=-1, /) method of _io.TextIOWrapper instance
    Read at most n characters from stream.

    Read from underlying buffer until we have n characters or we hit EOF.
    If n is negative or omitted, read until EOF.

raw_input फ़ंक्शन, input (पायथन 2 में raw_input )

बिल्टिन फ़ंक्शन input मानक इनपुट से एक नई लाइन तक पढ़ता है, जो छीन लिया जाता है ( print पूरक करता है, जो डिफ़ॉल्ट रूप से एक नई लाइन जोड़ता है।) ऐसा तब तक होता है जब तक यह EOFError (फ़ाइल का अंत) न हो, जिस बिंदु पर यह EOFError उठाता है।

इस प्रकार, यहां बताया गया है कि आप stdin से पढ़ने के लिए पायथन 3 (या पायथन 2 में raw_input ) में input का उपयोग कैसे कर सकते हैं - इसलिए हम एक पायथन मॉड्यूल बनाते हैं जिसे हम stdindemo.py कहते हैं:

$ python -c "print('try:\n    while True:\n        print(input())\nexcept EOFError:\n    pass')" > stdindemo.py 

और आइए यह सुनिश्चित करने के लिए इसे वापस प्रिंट करें कि हम उम्मीद करते हैं:

$ python -c "import sys; sys.stdout.write(sys.stdin.read())" < stdindemo.py 
try:
    while True:
        print(input())
except EOFError:
    pass

फिर, input नई लाइन तक पढ़ता है और अनिवार्य रूप से इसे लाइन से स्ट्रिप्स करता है। print एक नई लाइन जोड़ता है। इसलिए जब वे इनपुट को संशोधित करते हैं, तो उनके संशोधन रद्द हो जाते हैं। (इसलिए वे अनिवार्य रूप से एक-दूसरे के पूरक हैं।)

और जब input अंत-फ़ाइल फ़ाइल प्राप्त करता है, तो यह EOFError उठाता है, जिसे हम अनदेखा करते हैं और फिर प्रोग्राम से बाहर निकलते हैं।

और लिनक्स / यूनिक्स पर, हम बिल्ली से पाइप कर सकते हैं:

$ cat inputs.txt | python -m stdindemo
foo
bar
baz

या हम सिर्फ stdin से फ़ाइल को रीडायरेक्ट कर सकते हैं:

$ python -m stdindemo < inputs.txt 
foo
bar
baz

हम मॉड्यूल को स्क्रिप्ट के रूप में भी निष्पादित कर सकते हैं:

$ python stdindemo.py < inputs.txt 
foo
bar
baz

पाइथन 3 से अंतर्निहित input पर सहायता यहां दी गई है:

input(prompt=None, /)
    Read a string from standard input.  The trailing newline is stripped.

    The prompt string, if given, is printed to standard output without a
    trailing newline before reading input.

    If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
    On *nix systems, readline is used if available.

sys.stdin

यहां हम sys.stdin का उपयोग करके डेमो स्क्रिप्ट sys.stdin । फ़ाइल-जैसी ऑब्जेक्ट पर पुनरावृत्ति करने का प्रभावी तरीका फ़ाइल-जैसी ऑब्जेक्ट को इटरेटर के रूप में उपयोग करना है। इस इनपुट से stdout को लिखने के लिए पूरक विधि sys.stdout.write उपयोग sys.stdout.write :

$ python -c "print('import sys\nfor line in sys.stdin:\n    sys.stdout.write(line)')" > stdindemo2.py

यह सुनिश्चित करने के लिए इसे वापस प्रिंट करें कि यह सही दिखता है:

$ python -c "import sys; sys.stdout.write(sys.stdin.read())" < stdindemo2.py 
import sys
for line in sys.stdin:
    sys.stdout.write(line)

और फ़ाइल में इनपुट को पुनर्निर्देशित करना:

$ python -m stdindemo2 < inputs.txt
foo
bar
baz

एक आदेश में गोल्फ किया:

$ python -c "import sys; sys.stdout.write(sys.stdin.read())" < inputs.txt
foo
bar
baz

गोल्फिंग के लिए फाइल डिस्क्रिप्टर

चूंकि stdin और stdout लिए फ़ाइल डिस्क्रिप्टर क्रमश: 0 और 1 हैं, इसलिए हम उन्हें पायथन 3 (2 नहीं) में open लिए भी पास कर सकते हैं, और ध्यान दें कि हमें अभी भी stdout पर लिखने के लिए 'w' की आवश्यकता है)।

अगर यह आपके सिस्टम पर काम करता है, तो यह अधिक पात्रों को बंद कर देगा।

$ python -c "open(1,'w').write(open(0).read())" < inputs.txt
baz
bar
foo

पायथन 2 का io.open यह भी करता है, लेकिन आयात में बहुत अधिक जगह होती है:

$ python -c "from io import open; open(1,'w').write(open(0).read())" < inputs.txt 
foo
bar
baz

अन्य टिप्पणियों और उत्तरों को संबोधित करना

एक टिप्पणी ''.join(sys.stdin) सुझाव देती है लेकिन यह वास्तव में sys.stdin.read () से अधिक है - प्लस पायथन को मेमोरी में एक अतिरिक्त सूची बनाना चाहिए (इस प्रकार str.join सूची में नहीं होने पर काम करता है) - इसके विपरीत :

''.join(sys.stdin)
sys.stdin.read()

शीर्ष उत्तर से पता चलता है:

import fileinput

for line in fileinput.input():
    pass

लेकिन, चूंकि sys.stdin फ़ाइल एपीआई लागू करता है, जिसमें इटरेटर प्रोटोकॉल भी शामिल है, यह वही है:

import sys

for line in sys.stdin:
    pass

एक और जवाब यह सुझाव देता है। बस याद रखें कि यदि आप इसे दुभाषिया में करते हैं, तो आपको Ctrl - d करना होगा यदि आप लिनक्स या मैक पर हैं, या विंडोज़ ( Ctrl के बाद) पर Ctrl - z को अंत-फ़ाइल फ़ाइल को भेजने के लिए प्रक्रिया। साथ ही, वह उत्तर print(line) सुझाव देता है - जो अंत में एक '\n' जोड़ता है - इसके बजाय print(line, end='') उपयोग करें (यदि पायथन 2 में, आपको from __future__ import print_function आवश्यकता होगी)।

fileinput लिए असली उपयोग-केस फाइलों की एक श्रृंखला में पढ़ने के लिए है।

मैं कोड कोड गोल्फ चुनौतियों में से कुछ करने की कोशिश कर रहा हूं, लेकिन उन्हें सभी को stdin से इनपुट की आवश्यकता होती है। मैं इसे पायथन में कैसे प्राप्त करूं?


Sys.stdin का उपयोग करके सभी एवरों पर बिल्डिंग, यदि आप कम से कम एक तर्क मौजूद हैं, तो आप तर्क फ़ाइल से पढ़ने के लिए निम्न की तरह कुछ भी कर सकते हैं, और अन्यथा stdin पर वापस आ सकते हैं:

import sys
f = open(sys.argv[1]) if len(sys.argv) > 1 else sys.stdin    
for line in f:
#     Do your stuff

और इसे या तो इस्तेमाल करें

$ python do-my-stuff.py infile.txt

या

$ cat infile.txt | python do-my-stuff.py

या और भी

$ python do-my-stuff.py < infile.txt

इससे आपकी पाइथन लिपि कई जीएनयू / यूनिक्स प्रोग्राम जैसे cat , grep और sed तरह व्यवहार करेगी।


आप stdin से पढ़ सकते हैं और फिर इनपुट को "डेटा" में निम्नानुसार स्टोर कर सकते हैं:

data = ""
for line in sys.stdin:
    data += line

इस से सम्बन्धित:

for line in sys.stdin:

मैंने अभी इसे बहुत बड़ी फ़ाइल के लिए अजगर 2.7 (किसी और के सुझाव के बाद) पर कोशिश की है, और मैं इसकी सिफारिश नहीं करता हूं, ठीक ऊपर उल्लिखित कारणों के लिए (कुछ भी लंबे समय तक नहीं होता)।

मैं थोड़ा और पाइथोनिक समाधान के साथ समाप्त हुआ (और यह बड़ी फ़ाइलों पर काम करता है):

with open(sys.argv[1], 'r') as f:
    for line in f:

फिर मैं स्क्रिप्ट को स्थानीय रूप से चला सकता हूं:

python myscript.py "0 1 2 3 4..." # can be a multi-line string or filename - any std.in input will work

एक विकल्प नीचे दिखाए गए इनपुट फ़ंक्शन का उपयोग करना है। यदि आप डेटा प्रकार के बारे में निश्चित नहीं हैं तो raw_input विधि भी है।

#!/usr/bin/env python

number = input("Please enter a number : ")
print("Entered number is %d" % number)

कार्यक्रम चला रहा है:

python test1.py

Please enter a number : 55
Entered number is 55

संदर्भ: http://www.python-course.eu/input.php


ऐसा करने के कुछ तरीके हैं।

  • sys.stdin एक फ़ाइल जैसी ऑब्जेक्ट है जिस पर आप फ़ंक्शंस को read सकते read या readlines कर सकते read यदि आप सबकुछ पढ़ना चाहते हैं या आप सबकुछ पढ़ना चाहते हैं और इसे स्वचालित रूप से न्यूलाइन द्वारा विभाजित करना चाहते हैं। (आपको काम करने के लिए इसके लिए import sys करने की आवश्यकता है।)

  • यदि आप इनपुट के लिए उपयोगकर्ता को संकेत देना चाहते हैं, तो आप Python 2.X में raw_input का उपयोग कर सकते हैं, और केवल पायथन 3 में input कर सकते हैं।

  • यदि आप वास्तव में केवल कमांड लाइन विकल्पों को पढ़ना चाहते हैं, तो आप sys.argv सूची के माध्यम से उन्हें एक्सेस कर सकते हैं।

आपको संभवतः एक उपयोगी संदर्भ होने के लिए पाइथन में I / O पर यह विकीबूक लेख भी मिलेगा।


जब इसे पाइप किए गए सॉकेट पर पढ़ने के लिए काम करने के लिए यह कुछ समस्याएं थीं। जब सॉकेट बंद हो गया तो उसने सक्रिय लूप में खाली स्ट्रिंग को वापस करना शुरू कर दिया। तो यह मेरा समाधान है (जिसे मैंने केवल लिनक्स में परीक्षण किया है, लेकिन उम्मीद है कि यह अन्य सभी प्रणालियों में काम करेगी)

import sys, os
sep=os.linesep

while sep == os.linesep:
    data = sys.stdin.readline()               
    sep = data[-len(os.linesep):]
    print '> "%s"' % data.strip()

तो यदि आप सॉकेट पर सुनना शुरू करते हैं तो यह ठीक से काम करेगा (उदाहरण के लिए बैश में):

while :; do nc -l 12345 | python test.py ; done

और आप इसे टेलनेट के साथ कॉल कर सकते हैं या बस ब्राउजर को लोकहोस्ट पर इंगित कर सकते हैं: 12345


दूसरों द्वारा प्रस्तावित उत्तर:

for line in sys.stdin:
  print line

बहुत सरल और पायथनिक है, लेकिन यह ध्यान दिया जाना चाहिए कि स्क्रिप्ट इनपुट की लाइनों पर पुनरावृत्ति शुरू करने से पहले ईओएफ तक प्रतीक्षा करेगी।

इसका मतलब है कि tail -f error_log | myscript.py tail -f error_log | myscript.py अपेक्षित लाइनों को संसाधित नहीं करेगा।

ऐसे उपयोग के मामले के लिए सही लिपि होगी:

while 1:
    try:
        line = sys.stdin.readline()
    except KeyboardInterrupt:
        break

    if not line:
        break

    print line

अद्यतन करें
टिप्पणियों से यह साफ़ कर दिया गया है कि पायथन 2 पर केवल बफरिंग शामिल हो सकती है, ताकि आप प्रिंट कॉल जारी होने से पहले बफर भरने या ईओएफ की प्रतीक्षा कर सकें।


मैं बहुत आश्चर्यचकित हूं कि किसी ने अभी तक इस हैक का उल्लेख नहीं किया है:

python -c "import sys;print (''.join([l for l in sys.stdin.readlines()]))"

दोनों python2 और पायथन 3 के साथ संगत


यह मानक आउटपुट में मानक इनपुट गूंज जाएगा:

import sys
line = sys.stdin.readline()
while line:
    print line,
    line = sys.stdin.readline()

लर्निंग पायथन से यहां है:

import sys
data = sys.stdin.readlines()
print "Counted", len(data), "lines."

यूनिक्स पर, आप कुछ ऐसा करके इसका परीक्षण कर सकते हैं:

% cat countlines.py | python countlines.py 
Counted 3 lines.

विंडोज या डॉस पर, आप करेंगे:

C:\> type countlines.py | python countlines.py 
Counted 3 lines.

sys.stdin से पढ़ें, लेकिन विंडोज़ पर बाइनरी डेटा पढ़ने के लिए, आपको अतिरिक्त सावधानी बरतनी चाहिए, क्योंकि sys.stdin टेक्स्ट मोड में खोला गया है और यह दूषित \r\n को \n

यदि विंडोज + पायथन 2 का पता चला है, और पायथन 3 पर sys.stdin.buffer उपयोग करें, तो समाधान मोड को बाइनरी पर सेट sys.stdin.buffer

import sys

PY3K = sys.version_info >= (3, 0)

if PY3K:
    source = sys.stdin.buffer
else:
    # Python 2 on Windows opens sys.stdin in text mode, and
    # binary data that read from it becomes corrupted on \r\n
    if sys.platform == "win32":
        # set sys.stdin to binary mode
        import os, msvcrt
        msvcrt.setmode(sys.stdin.fileno(), os.O_BINARY)
    source = sys.stdin

b = source.read()

n = int(raw_input())
for i in xrange(n):
    name, number = raw_input().split()




stdin