Я пытаюсь выполнить некоторые из code golf, но все они требуют ввода, который нужно взять из stdin. Как я могу получить это в Python?
Вы можете использовать модуль fileinput:
import fileinput
for line in fileinput.input():
pass
fileinput будет проходить по всем строкам ввода, указанным как имена файлов, заданные в аргументах командной строки, или стандартный ввод, если аргументы не предоставлены.
Примечание: line будет содержать завершающий символ новой строки; чтобы удалить его используйте line.rstrip()
Есть несколько способов сделать это.
sys.stdin - это файл-подобный объект, на котором вы можете вызывать функции read или readlines если вы хотите прочитать все или хотите все прочитать и разделить на новую строку автоматически. (Для этого вам нужно import sys.)
Если вы хотите raw_input пользователя для ввода, вы можете использовать raw_input в Python 2.X и просто input в Python 3.
Если вы просто хотите прочитать параметры командной строки, вы можете получить к ним доступ через список sys.argv.
Вы, вероятно, найдете эту статью в Википедии о вводе-выводе в Python также полезной ссылкой.
import sys
for line in sys.stdin:
print(line)
Обратите внимание, что в конце будет добавлен символ новой строки. Чтобы удалить перевод строки в конце, используйте line.rstrip(), как сказал @brittohalloran.
Python также имеет встроенные функции input() и raw_input(). См. Документацию Python в Встроенные функции.
Например,
name = raw_input("Enter your name: ") # Python 2.x
или
name = input("Enter your name: ") # Python 3
Здесь из Learning Python:
import sys
data = sys.stdin.readlines()
print "Counted", len(data), "lines."
В Unix вы можете проверить его, выполнив что-то вроде:
% cat countlines.py | python countlines.py
Counted 3 lines.
В Windows или DOS вы должны:
C:\> type countlines.py | python countlines.py
Counted 3 lines.
Ответ, предложенный другими:
for line in sys.stdin:
print line
очень прост и pythonic, но следует отметить, что script будет ждать до EOF перед началом итерации по строкам ввода.
Это означает, что tail -f error_log | myscript.py не будет обрабатывать строки, как ожидалось.
Правильный script для такого варианта использования:
while 1:
try:
line = sys.stdin.readline()
except KeyboardInterrupt:
break
if not line:
break
print line
UPDATE
Из комментариев было очищено то, что на python 2 может быть только буферизация, так что вы в конечном итоге ожидаете заполнения буфера или EOF до того, как выйдет запрос на печать.
Как вы читаете со стандартного ввода в Python?
Я пытаюсь выполнить некоторые задачи кода, но все они требуют ввода от stdin. Как мне получить это в Python?
Вы можете использовать:
sys.stdin - Файловый объект - вызовите sys.stdin.read(), чтобы прочитать все.input(prompt) - передать ему необязательный запрос на вывод, он читает от стандартного ввода до первой новой строки, которую удаляет. Вам придется делать это несколько раз, чтобы получить больше строк, в конце ввода это вызывает EOFError. (Вероятно, не подходит для игры в гольф.) В Python 2 это rawinput(prompt).open(0).read() - В Python 3 встроенная функция open принимает файловые дескрипторы (целые числа, представляющие ресурсы ввода-вывода операционной системы), а 0 - дескриптор stdin. Он возвращает файл-подобный объект, такой как sys.stdin - вероятно, ваш лучший выбор для игры в гольф. В Python 2 это io.open.open('/dev/stdin').read() - аналогично open(0), работает на Python 2 и 3, но не на Windows (или даже Cygwin).fileinput.input() - возвращает итератор над строками во всех файлах, перечисленных в sys.argv[1:], или stdin, если не указан. Используйте как ''.join(fileinput.input()).И sys, и fileinput должны быть импортированы соответственно.
sys.stdin, совместимые с Python 2 и 3, Windows, UnixВам просто нужно 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 в Python 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 из Python 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 в Python 2)Встроенная функция input считывает со стандартного ввода до новой строки, которая удаляется (дополняет print, который по умолчанию добавляет новую строку.) Это происходит до тех пор, пока не получит EOF (конец файла), после чего она поднимается EOFError.
Таким образом, вот как вы можете использовать input в Python 3 (или raw_input в Python 2) для чтения из stdin - поэтому мы создаем модуль Python, который мы называем 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, которую мы игнорируем, а затем выходим из программы.
А в Linux/Unix мы можем передать из cat:
$ cat inputs.txt | python -m stdindemo
foo
bar
baz
Или мы можем просто перенаправить файл из стандартного ввода:
$ python -m stdindemo < inputs.txt
foo
bar
baz
Мы также можем выполнить модуль как скрипт:
$ python stdindemo.py < inputs.txt
foo
bar
baz
Вот справка по встроенному input из Python 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. Эффективный способ перебора файловоподобного объекта заключается в использовании файловоподобного объекта в качестве итератора. Дополнительный метод записи в стандартный вывод этого ввода - просто использовать 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 в Python 3 (не в 2, и обратите внимание, что нам все еще нужен 'w' для записи в stdout).
Если это работает в вашей системе, это сбрит больше символов.
$ python -c "open(1,'w').write(open(0).read())" < inputs.txt
baz
bar
foo
Python 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() - плюс Python должен создать дополнительный список в памяти (то, как работает str.join, когда нет списка) - для контраста:
''.join(sys.stdin)
sys.stdin.read()
Верхний ответ предполагает:
import fileinput
for line in fileinput.input():
pass
Но, поскольку sys.stdin реализует файловый API, включая протокол итератора, он такой же, как и этот:
import sys
for line in sys.stdin:
pass
Другой ответ подсказывает это. Просто помните, что если вы делаете это в интерпретаторе, вам нужно сделать Ctrl - d, если вы работаете в Linux или Mac, или Ctrl - z в Windows (после Enter), чтобы отправить символ конца файла процессу. Кроме того, в этом ответе предлагается print(line) - который добавляет '\n' к концу - используйте вместо него print(line, end='') (если в Python 2 вам понадобится from __future__ import print_function).
Реальный вариант использования fileinput предназначен для чтения в серии файлов.
Это приведет к стандартному входу стандартного вывода:
import sys
line = sys.stdin.readline()
while line:
print line,
line = sys.stdin.readline()
Основываясь на всех anwers с помощью 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
Это приведет к тому, что ваш Python script будет вести себя как многие программы GNU/Unix, такие как cat, grep и sed.
argparse - это простое решениеПример совместим с обеими версиями Python 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 -
Следующий чип кода поможет вам (он будет читать все блокировки stdin до EOF в одну строку):
import sys
input_str = sys.stdin.read()
print input_str.split()
Попробуйте следующее:
import sys
print sys.stdin.read().upper()
и проверьте его с помощью:
$ echo "Hello World" | python myFile.py
Вы можете читать из stdin, а затем хранить входы в "данные" следующим образом:
data = ""
for line in sys.stdin:
data += line
Считайте из sys.stdin, но чтобы читать двоичные данные в Windows, вам нужно быть особенно осторожным, потому что sys.stdin открывается в текстовом режиме, и это приведет к повреждению \r\n, заменяющему их с \n.
Решение состоит в том, чтобы установить режим в двоичный, если обнаружен Windows + Python 2, а на Python 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()
Я очень удивлен, что никто пока не упоминал об этом хаке:
python -c "import sys;print (''.join([l for l in sys.stdin.readlines()]))"
совместим с python2 и python3
Проблема с решением
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)
У меня возникли некоторые проблемы при работе с ним для чтения через сокеты, подключенные к нему. Когда сокет закрылся, он начал возвращать пустую строку в активном цикле. Так что это мое решение для меня (которое я тестировал только в Linux, но надеюсь, что он работает во всех других системах)
import sys, os
sep=os.linesep
while sep == os.linesep:
data = sys.stdin.readline()
sep = data[-len(os.linesep):]
print '> "%s"' % data.strip()
Итак, если вы начнете прослушивать сокет, он будет работать правильно (например, в bash):
while :; do nc -l 12345 | python test.py ; done
И вы можете вызвать его с помощью telnet или просто указать браузер на localhost: 12345
Относительно этого:
for line in sys.stdin:
Я просто попробовал это на python 2.7 (после какого-то другого предложения) для очень большого файла, и я не рекомендую его именно по причинам, упомянутым выше (ничего не происходит в течение длительного времени).
В итоге у меня появилось несколько более питоническое решение (и оно работает с большими файлами):
with open(sys.argv[1], 'r') as f:
for line in f:
Затем я могу запустить script локально как:
python myscript.py "0 1 2 3 4..." # can be a multi-line string or filename - any std.in input will work
n = int(raw_input())
for i in xrange(n):
name, number = raw_input().split()
Один из вариантов - использовать функцию ввода, как показано ниже. Существует также метод 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
Существует os.read(0, x) который читает xbytes из 0, что представляет собой стандартный ввод. Это небуферизованное чтение, более низкий уровень, чем sys.stdin.read()
Для Python 3 это будет:
# Filename e.g. cat.py
import sys
for line in sys.stdin:
print(line, end="")
Это в основном простая форма cat (1), так как она не добавляет символ новой строки после каждой строки. Вы можете использовать это (после того, как Вы отметили исполняемый файл, используя chmod +x cat.py например:
echo Hello | ./cat.py
При использовании команды -c в качестве хитрого способа вместо чтения стандартного stdin (и в некоторых случаях более гибкого) вы можете также передать команду сценария оболочки в команду python, поместив команду sell в кавычки в скобках, начинающихся с знак $.
например
python3 -c "import sys; print(len(sys.argv[1].split('\n')))" "$(cat ~/.goldendict/history)"
Это будет подсчитывать количество строк из файла истории goldendict.