ඔබ stdin වෙතින් කියවන්නේ කෙසේද?

මම කේත ගොල්ෆ් අභියෝග කිහිපයක් කිරීමට උත්සාහ කරමි , නමුත් ඒ සියල්ලටම ආදානය ලබා ගත යුතුය stdin. මම එය පයිතන් වලින් ලබා ගන්නේ කෙසේද?

ඔබට fileinputමොඩියුලය භාවිතා කළ හැකිය :

import fileinput

for line in fileinput.input():
    pass

fileinput විධාන රේඛා පරාමිතීන්හි දක්වා ඇති ගොනු නාමයන් ලෙස දක්වා ඇති ආදානයේ ඇති සියලුම රේඛා හරහා හෝ තර්ක ලබා නොදුනහොත් සම්මත ආදානය හරහා ලූප වේ.

සටහන: lineපසුපස නව රේඛාවක් අඩංගු වේ; එය ඉවත් කිරීමට භාවිතා කරන්නline.rstrip()

එය කිරීමට ක්‍රම කිහිපයක් තිබේ.

• sys.stdinගොනුව වැනි වස්තුවක් කාර්යයන් මත ඔබ ඇමතිය හැකි වේ readහෝ readlines, ඔබට සියල්ල කියවීමට අවශ්ය නම් හෝ, ඔබට සියල්ල කියවා ස්වයංක්රීයව නව පේළියකට යොමු කිරීමේ අක්ෂරය මගින් එය බෙදීමට අවශ්ය. (මෙය ක්‍රියාත්මක වීමට ඔබට අවශ්‍යය import sys.)

• ඔබට අවශ්ය නම් මතක් ආදානය සඳහා පරිශීලක, ඔබ භාවිතා කළ හැකිය raw_inputPython 2.X, සහ පමණක් inputPython 3.

• ඔබට සැබවින්ම විධාන රේඛා විකල්ප කියවීමට අවශ්‍ය නම්, ඔබට ඒවා sys.argv ලැයිස්තුව හරහා ප්‍රවේශ විය හැකිය .

පයිතන් හි I / O පිළිබඳ මෙම විකිබුක් ලිපිය ප්‍රයෝජනවත් සඳහනක් ලෙස ඔබ බොහෝ විට සොයා ගනු ඇත .

import sys

for line in sys.stdin:
    print(line)

මෙයට අවසානයේ නව රේඛා අක්ෂරයක් ඇතුළත් වන බව සලකන්න. නව line.rstrip()රේඛාව අවසානයේ ඉවත් කිරීමට @ බ්‍රිටෝහෝලෝරන් පැවසූ පරිදි භාවිතා කරන්න .

පයිතන් තුළ ගොඩනංවන ලද කාර්යයන් input()ද raw_input()ඇත. බිල්ට් කාර්යයන් යටතේ පයිතන් ප්‍රලේඛනය බලන්න .

උදාහරණයක් වශයෙන්,

name = raw_input("Enter your name: ")   # Python 2.x

හෝ

name = input("Enter your name: ")   # Python 3

ඉගෙනීමේ පයිතන් වෙතින් මෙන්න :

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.

පයිතන්හි stdin වෙතින් ඔබ කියවන්නේ කෙසේද?

මම කේත ගොල්ෆ් අභියෝග කිහිපයක් කිරීමට උත්සාහ කරමි, නමුත් ඒ සියල්ලටම අවශ්‍ය වන්නේ ආදානය stdin වෙතින් ලබා ගැනීමයි. මම එය පයිතන් වලින් ලබා ගන්නේ කෙසේද?

ඔයාට පාවිච්චි කරන්න පුළුවන්:

• sys.stdin- ගොනුවක් වැනි වස්තුවක් - sys.stdin.read()සියල්ල කියවීමට අමතන්න .
• input(prompt)- එය ප්‍රතිදානය සඳහා විකල්ප විමසුමක් ලබා දෙන්න, එය stdin සිට පළමු නව රේඛාව දක්වා කියවනු ලැබේ. තවත් රේඛා ලබා ගැනීම සඳහා ඔබට මෙය නැවත නැවතත් කළ යුතුව ඇත, ආදානය අවසානයේ එය EOFError මතු කරයි. (බොහෝ විට ගොල්ෆ් ක්‍රීඩා කිරීම සඳහා එතරම් හොඳ නැත.) පයිතන් 2 හි මෙය වේ rawinput(prompt).
• open(0).read()- පයිතන් 3 හි, බිල්ඩින් ශ්‍රිතය ගොනු විස්තර කරන්නන් openපිළිගනී (මෙහෙයුම් පද්ධති IO සම්පත් නියෝජනය කරන පූර්ණ සංඛ්‍යා), සහ 0 යනු විස්තර කරන්නා ය . එය ගොල්ෆ් වැනි වස්තුවක් නැවත ලබා දෙයි - බොහෝ විට ගොල්ෆ් ක්‍රීඩාව සඳහා ඔබේ හොඳම ඔට්ටුව. පයිතන් 2 හි මෙය වේ .stdinsys.stdinio.open
• open('/dev/stdin').read()- සමාන open(0), පයිතන් 2 සහ 3 මත ක්‍රියා කරයි, නමුත් වින්ඩෝස් මත නොවේ (හෝ සිග්වින් පවා).
• fileinput.input()- ලැයිස්තුගත කර ඇති සියලුම ලිපිගොනු වල රේඛා හරහා sys.argv[1:]ඉරේටරයක් ​​ලබා දෙයි, නැතහොත් ලබා නොදුනහොත් stdin. වැනි භාවිතා කරන්න ''.join(fileinput.input()).

දෙකම sysසහ fileinputපිළිවෙලින් ආනයනය කළ යුතුය.

sys.stdinපයිතන් 2 සහ 3, වින්ඩෝස්, යුනික්ස් සමඟ අනුකූල වන ඉක්මන් උදාහරණ

ඔබ කළ යුත්තේ readසිට sys.stdin: උදාහරණයක් ලෙස, ඔබ නල දත්ත stdin කිරීමට නම්,

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

sys.stdinඑය පෙරනිමි පෙළ ප්‍රකාරයේදී අපට දැක ගත හැකිය :

>>> import sys
>>> sys.stdin
<_io.TextIOWrapper name='<stdin>' mode='r' encoding='UTF-8'>

ගොනු උදාහරණය

ඔබට ගොනුවක් ඇති බව පවසන්න inputs.txt, අපට එම ගොනුව පිළිගෙන එය නැවත ලිවිය හැකිය:

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

දිගු පිළිතුර

මෙන්න ක්‍රම දෙකක් භාවිතා කරමින් සම්පූර්ණ, පහසුවෙන් ප්‍රතිවර්තනය කළ හැකි නිරූපණයක්, බිල්ඩින් ශ්‍රිතය, input( raw_inputපයිතන් 2 හි භාවිතා කරන්න ), සහ 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

sys.stdin.readපයිතන් 3 හි උපකාරය මෙන්න :

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.

බිල්ටින් ශ්‍රිතය, input( raw_inputපයිතන් 2 හි)

බිල්ඩින් ශ්‍රිතය inputසම්මත ආදානයේ සිට නව රේඛාවක් දක්වා කියවනු ලැබේ, එය ඉවත් කරනු ලැබේ (අනුපූරකව print, පෙරනිමියෙන් නව රේඛාවක් එක් කරයි.) මෙය සිදුවන්නේ එය EOF (ගොනුවේ අවසානය) ලබා ගන්නා තෙක්ය, එම අවස්ථාවේදී එය මතු EOFErrorවේ.

මේ අනුව, ඔබට stdin වෙතින් කියවීම inputසඳහා Python 3 (හෝ raw_inputPython 2) භාවිතා කළ හැකි ආකාරය මෙන්න - එබැවින් අපි 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අවසන්-of-ගොනුව චරිතය ලැබෙන, එය අප නොසලකා පසුව වැඩසටහනෙන් ඉවත් කරන 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

inputපයිතන් 3 හි බිල්ඩින් සඳහා උදව් මෙන්න :

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. ගොනුවක් වැනි වස්තුවක් හරහා නැවත ක්‍රියා කිරීමට ඇති කාර්යක්ෂම ක්‍රමය නම් ගොනුව වැනි වස්තුව අනුකාරකයක් ලෙස භාවිතා කිරීමයි. මෙම ආදානයෙන් stdout වෙත ලිවීමට අනුපූරක ක්‍රමය වන්නේ සරලව භාවිතා කිරීමයි 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 වන අතර, අප ද එම උරුම විය හැකි open(අපි තවමත් stdout වෙත ලිඛිතව සඳහා 'W' අවශ්ය බව සඳහන් කර 2, සහ) Python 3.

මෙය ඔබේ පද්ධතියේ ක්‍රියාත්මක වන්නේ නම්, එය තවත් අක්ෂර රැවුල කපයි.

$ 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.stdiniterator ප්‍රොටෝකෝලය ඇතුළුව ගොනු API ක්‍රියාත්මක කරන බැවින් එය මේ හා සමාන වේ:

import sys

for line in sys.stdin:
    pass

තවත් පිළිතුර වන්නේ මෙම යෝජනා කරමු. මතක තබා ගන්න ඔබ එය පරිවර්තකයෙකු තුළ කරන්නේ නම්, ඔබ කළ යුත්තේ Ctrl- dඔබ ලිනක්ස් හෝ මැක්හි නම්, හෝ Ctrl- zවින්ඩෝස් හි (පසුව Enter) ගොනුවේ අවසාන අක්‍ෂරය ක්‍රියාවලියට යැවීමට ය. එසේම, එම පිළිතුරෙන් ඇඟවෙන්නේ print(line)- එය '\n'අවසානයට එකතු කරන - print(line, end='')ඒ වෙනුවට භාවිතා කරන්න (පයිතන් 2 හි නම්, ඔබට අවශ්‍ය වනු ඇත from __future__ import print_function).

සඳහා සැබෑ භාවිත අවස්ථාව fileinputවන්නේ ලිපිගොනු මාලාවක් කියවීමයි.

අන් අය විසින් යෝජනා කරන ලද පිළිතුර:

for line in sys.stdin:
  print line

ඉතා සරල හා පයිතොනික් වේ, නමුත් ආදාන රේඛා මත නැවත යෙදීමට පෙර ස්ක්‍රිප්ට් EOF තෙක් බලා සිටින බව සැලකිල්ලට ගත යුතුය.

මෙයින් අදහස් කරන්නේ tail -f error_log | myscript.pyඅපේක්ෂිත පරිදි රේඛා සැකසෙන්නේ නැති බවයි.

එවැනි භාවිත නඩුවක් සඳහා නිවැරදි පිටපත වනුයේ:

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

    if not line:
        break

    print line

යාවත්කාලීන
කිරීම අදහස් වලින් පැහැදිලි වී ඇත්තේ පයිතන් 2 හි පමණක් බෆරින් සම්බන්ධ විය හැකි බැවින් මුද්‍රණ ඇමතුම නිකුත් කිරීමට පෙර බෆරය පිරවීම හෝ ඊඕඑෆ් එනතෙක් බලා සිටීමයි.

මෙය සම්මත ප්‍රතිදානය සම්මත ප්‍රතිදානයට ප්‍රතිරාවය කරයි:

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

භාවිතා කරන සියලුම ඇන්වර්ස් මත ගොඩනැඟීමෙන් sys.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

එවැනි බොහෝ GNU / යුනික්ස් වැඩසටහන් වැනි ඔබේ Python කේත රචනය වටේ සංචාරවල යෙදෙමින් කරන්න වනු ඇත cat, grepහා sed.

argparse පහසු විසඳුමකි

උදාහරණය පයිතන් අනුවාද 2 සහ 3 යන දෙකටම අනුකූල වේ:

#!/usr/bin/python

import argparse
import sys

parser = argparse.ArgumentParser()

parser.add_argument('infile',
                    default=sys.stdin,
                    type=argparse.FileType('r'),
                    nargs='?')

args = parser.parse_args()

data = args.infile.read()

ඔබට මෙම ස්ක්‍රිප්ට් එක විවිධාකාරයෙන් ධාවනය කළ හැකිය:

1. භාවිතා කිරීම stdin

echo 'foo bar' | ./above-script.py

  හෝ වෙනුවට කෙටි echoවිසින් මෙහි සංගීත :

./above-script.py <<< 'foo bar'

2. ගොනු නාම තර්කයක් භාවිතා කිරීම

echo 'foo bar' > my-file.data
./above-script.py my-file.data

3. stdinවිශේෂ ගොනු නාමය හරහා භාවිතා කිරීම-

echo 'foo bar' | ./above-script.py -

පහත දැක්වෙන කේත චිපය ඔබට උපකාරී වනු ඇත (එය සියලුම ස්ටීඩින් අවහිර කිරීම් EOFඑක නූලකට කියවනු ඇත ):

import sys
input_str = sys.stdin.read()
print input_str.split()

කිසිවෙකු මේ කඩුල්ල ගැන මෙතෙක් සඳහන් නොකිරීම ගැන මම පුදුම වෙමි:

python -c "import sys; set(map(sys.stdout.write,sys.stdin))"

python2 හි ඔබට set()ඇමතුම අතහැර දැමිය හැකිය , නමුත් එය දෙයාකාරයෙන්ම කියනු ඇත

මේක උත්සාහ කරන්න:

import sys

print sys.stdin.read().upper()

එය සමඟ පරීක්ෂා කරන්න:

$ echo "Hello World" | python myFile.py

ඔබට stdin වෙතින් කියවිය හැකි අතර පසුව ආදාන "දත්ත" වෙත ගබඩා කළ හැකිය :

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

සිට කියවන්න sys.stdin, නමුත් වින්ඩෝස් හි ද්විමය දත්ත කියවීමට , ඔබ වැඩිපුර සැලකිලිමත් විය යුතුය, මන්ද sys.stdinපෙළ මාදිලියේ විවෘත කර ඇති අතර ඒවා \r\nප්‍රතිස්ථාපනය කිරීමෙන් එය දූෂිත වනු ඇත \n.

විසඳුම වන්නේ වින්ඩෝස් + පයිතන් 2 අනාවරණය වුවහොත් සහ පයිතන් 3 භාවිතයේදී ද්විමය ලෙස මාදිලිය සැකසීමයි 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()

මම පහත දැක්වෙන ක්‍රමය භාවිතා කරමි, එය stdin වෙතින් නූලක් ලබා දෙයි (මම එය json විග්‍රහ කිරීම සඳහා භාවිතා කරමි). එය වින්ඩෝස් මත නල සහ විමසුමක් සමඟ ක්‍රියා කරයි (තවමත් ලිනක්ස් හි පරීක්ෂා කර නොමැත). විමසීමේදී, පේළි දෙකක බිඳීම් ආදානයේ අවසානය දක්වයි.

def get_from_stdin():

  lb = 0
  stdin = ''

  for line in sys.stdin:
    if line == "\n":
        lb += 1
        if lb == 2:
            break
    else:
        lb = 0
        stdin += line

  return stdin

විසඳුම සමඟ මට ඇති ගැටළුව

import sys

for line in sys.stdin:
    print(line)

ඔබ stdin වෙත කිසිදු දත්තයක් ලබා නොදුනහොත් එය සදහටම අවහිර වනු ඇත. ඒ නිසයි මම මෙම පිළිතුරට ප්‍රිය කරන්නේ : පළමුව stdin පිළිබඳ දත්ත තිබේදැයි පරීක්ෂා කර එය කියවන්න. මෙය මම අවසන් කළේ:

import sys
import select

# select(files to read from, files to write to, magic, timeout)
# timeout=0.0 is essential b/c we want to know the asnwer right away
if select.select([sys.stdin], [], [], 0.0)[0]:
    help_file_fragment = sys.stdin.read()
else:
    print("No data passed to stdin", file=sys.stderr)
    sys.exit(2)

සොකට් වලට නල මාර්ගයෙන් කියවීම සඳහා මෙය ක්‍රියාත්මක කිරීමේදී මට යම් ගැටළු ඇති විය. සොකට් එක වසා දැමූ විට එය ක්‍රියාකාරී ලූපයක හිස් නූලක් නැවත ලබා දීමට පටන් ගත්තේය. එබැවින් මෙය මගේ විසඳුමයි (මම ලිනක්ස් වලින් පමණක් පරීක්‍ෂා කළ නමුත් එය අනෙක් සියලුම පද්ධතිවල ක්‍රියාත්මක වේ යැයි සිතමි)

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

ඔබට එය ටෙල්නෙට් සමඟ ඇමතිය හැකිය, නැතහොත් බ්‍රව්සරයක් localhost වෙත යොමු කරන්න: 12345

මේ සම්බන්ධයෙන්:

for line in sys.stdin:

මම එය ඉතා විශාල ගොනුවක් සඳහා පයිතන් 2.7 (වෙනත් කෙනෙකුගේ යෝජනාවක් අනුගමනය කරමින්) අත්හදා බැලුවෙමි, මම එය නිර්දේශ නොකරමි, හරියටම ඉහත සඳහන් කළ හේතු නිසා (කිසිවක් දීර් long කාලයක් තිස්සේ සිදු නොවේ).

මම තරමක් වැඩි පයිතොනික් විසඳුමක් සමඟ අවසන් කළෙමි (එය විශාල ලිපිගොනු මත ක්‍රියා කරයි):

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

සඳහා python, 3 බව වනු ඇත:

# Filename e.g. cat.py
import sys

for line in sys.stdin:
    print(line, end="")

මෙය මූලික වශයෙන් බළලුන්ගේ සරල ආකාරයකි (1), එය එක් එක් පේළියට පසුව නව රේඛාවක් එක් නොකරයි. ඔබට මෙය භාවිතා කළ හැකිය (ඔබ ගොනුව ක්‍රියාත්මක කළ හැකි chmod +x cat.pyලෙස සලකුණු කළ පසු :

echo Hello | ./cat.py

නැත os.read(0, x) stdin නියෝජනය කරන 0 සිට xbytes සඳහන් වන්නේ. මෙය නොවරදින කියවීමකි, sys.stdin.read () ට වඩා අඩු මට්ටමකි

-cවිධානය භාවිතා කරන විට , කියවීම වෙනුවට උපක්‍රමශීලී ක්‍රමයක් ලෙසstdin (සහ සමහර අවස්ථාවල වඩාත් නම්‍යශීලී) ඔබට ෂෙල් ස්ක්‍රිප්ට් විධානයක් මෙන්ම ඔබේ පයිතන් විධානයටත් යැවිය හැකිය $.

උදා

python3 -c "import sys; print(len(sys.argv[1].split('\n')))" "$(cat ~/.goldendict/history)"

මෙය ගෝල්ඩෙන්ඩික්ට් හි ඉතිහාස ගොනුවේ පේළි ගණන ගණනය කරනු ඇත.