Я пытаюсь решить некоторые задачи из code golf, но все они требуют, чтобы входные данные были взяты из stdin
. Как я могу получить это в Python?
Вы можете использовать модуль fileinput
:
import fileinput
for line in fileinput.input():
pass
fileinput
перебирает все строки во входных данных, заданных в виде имен файлов, указанных в аргументах командной строки, или в стандартном вводе, если аргументы не указаны.
Примечание: line
будет содержать завершающую новую строку; чтобы удалить ее, используйте line.rstrip()
.
Есть несколько способов сделать это.
sys.stdin
- это файлоподобный объект, на котором вы можете вызвать функции read
или readlines
, если вы хотите прочитать все, или вы хотите прочитать все и разделить на новые строки автоматически. (Чтобы это работало, вам нужно импортировать sys
).
Если вы хотите предложить пользователю ввести данные, вы можете использовать raw_input
в Python 2.X, и просто input
в Python 3.
Если вы хотите просто прочитать параметры командной строки, вы можете получить к ним доступ через список sys.argv.
Вы, вероятно, найдете эту статью Викибука о вводе/выводе в Python полезным справочником.
``pyton импорт Сыс
для строки в sys.вывод: печать(линии) ``
Обратите внимание, что это будет содержать символ новой строки в конце. Чтобы удалить строку в конце, использовать линию.rstrip()` как @brittohalloran сказал.
Python также имеет встроенные функции ввода () и 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
очень простые и подходящие для Python, но следует отметить, что скрипт будет ждать, пока ВФ перед началом итерации по линии ввода.
Это означает, что хвост -F в функцию error_log | myscript.py не технологические линии, как ожидалось.
Правильный сценарий для такого случая будут:
while 1:
try:
line = sys.stdin.readline()
except KeyboardInterrupt:
break
if not line:
break
print line
Обновление Из комментариев выяснилось, что на Python 2 только там может быть буферизации участвует, так что вы в конечном итоге ждет заполнения буфера или EOF до печатного вызов выдается.
как ты читаешь из stdin в Python?
Я'м пытаются сделать некоторые кода проблем для гольфа, но все они требуют ввода из потока stdin. Как я могу сделать это в Python? Вы можете использовать:
sys файла.стандартный ввод
- файл-как объект - звонитеsys файла.устройства stdin.читать ()
, чтобы прочитать все.ввод(Подсказка)
- Пройти это дополнительная подсказка к выходу, он читает из stdin до первой строки, которую он снимает. Вы'd должны сделать это несколько раз, чтобы получить несколько строк, в конце входного поднимает eoferror генерируется. (Вероятно, не очень хорошо для игры в гольф.) В Python 2, это rawinput(приглашение)`.открытые(0).прочитать()
- в Python 3 функция встроенный "открыть" можно дескрипторы (целых чисел операционная система ресурсы ввода-вывода), а 0-дескрипторстандартный ввод
. Он возвращает файл-как объект, каксис.как stdin
- вероятно, ваш лучший ставку для игры в гольф. В Python 2, этоИо.откройте
.- открытый(' файл/dev/stdin-стандартный поток ввода').читать()
- похож на
открытые(0)`, работает на Python 2 и 3, но не на Windows (или даже под Cygwin).fileinput.входные()
- возвращает итератор над строки во всех файлах, перечисленных в таблице sys.аргумент argv[1:], или стандартный ввод, если не дано. Использовать как
''.присоединиться(fileinput.входные()). Оба пакет
sysи
fileinput` должны быть импортированы, соответственно, конечно.Быстрый
sys файла.примеры стандартный ввод
совместим с Python 2 и 3, ОС Windows, ОС UNIXНужно просто "прочитать" с
Сыс.как stdin
, например, если данные трубы в stdin:
$ echo foo | python -c "import sys; print(sys.stdin.read())"
foo
Мы видим, что представление sys.вывод в текстовом режиме по умолчанию: ``питон
импорт Сыс Сыс.устройства stdin <_io.TextIOWrapper наименование='<устройства stdin>' режим='Р' кодировка='кодировка UTF-8'> ``
пример файл
Скажем, у вас есть файл, `inputs.txt мы можем принять этот файл и запишите его обратно:
python -c "import sys; sys.stdout.write(sys.stdin.read())" < inputs.txt
Здесь'с полной, легко воспроизводимые демо, используя два метода, встроенные функции, ввод
(использовать raw_inputв Python 2), и
sys файла.устройства stdin`. Данные без изменений, так что обработка-это не операция.
Для начала, позвольте'ы создать файл для входов:
$ python -c "print('foo\nbar\nbaz')" > inputs.txt
И, используя код, который мы've уже видели, мы можем проверить, что мы'вэ создал файл:
$ python -c "import sys; sys.stdout.write(sys.stdin.read())" < inputs.txt
foo
bar
baz
Здесь'с помощью на представление sys.устройства stdin.читать с 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.
ввод
(raw_input
в Python 2)Встроенные функции ввода считывает из стандартного ввода до символа новой строки, который лишил (дополняя "печать", которая добавляет новую строку по умолчанию.) Это происходит, пока он не получает функция EOF (конец файла), в этот момент он поднимает eoferror генерируется
.
Таким образом, здесь's, как вы можете использовать ввод
в 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
И пусть's печать его обратно, чтобы убедиться, что он's, как мы ожидаем:
$ python -c "import sys; sys.stdout.write(sys.stdin.read())" < stdindemo.py
try:
while True:
print(input())
except EOFError:
pass
Опять же, вход считывает до символа новой строки и полосы из линии. "печать" добавляет новую строку. Так что пока они оба изменять входные, их модификаций отменить. (Так они по сути друг друга'ы дополнит.) И когда вход получает в конец файла символ, он поднимает eoferror генерируется, которые мы игнорируем, а затем выйдите из программы. И на Linux/Unix, мы можем трубка от кота:
$ 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
Здесь'с помощью ввода на встроенной от в 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`. Эффективный способ, чтобы выполнить итерации через файл-как объект, чтобы использовать файл-как объект, как итератор. Дополнительный метод писать в stdout от этого входа просто использовать представление sys.поток stdout.писать:
$ 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
Так как дескрипторы файлов для стандартного ввода и стандартного вывода являются 0 и 1, соответственно, мы можем также передавать их, чтобы открыть
в Python 3 (Не 2, и обратите внимание, что мы еще нужны 'ш' для записи на стандартный вывод).
Если это работает на вашей системе, он будет сбрить более символов.
$ python -c "open(1,'w').write(open(0).read())" < inputs.txt
baz
bar
foo
В Python 2'ы `Ио.откройте это, но импорт занимает намного больше места:
$ python -c "from io import open; open(1,'w').write(open(0).read())" < inputs.txt
foo
bar
baz
В одном из комментариев предлагается''.присоединиться(представление sys.как stdin)
для игры в гольф, но, что'ы на самом деле больше, чем сис.устройства stdin.прочитать() - плюс Python должна создавать дополнительный список в памяти (что'ул. как`.тогда работает, когда не дали список) - для контраста:
''.join(sys.stdin)
sys.stdin.read()
Верхний ответ предполагает:
import fileinput
for line in fileinput.input():
pass
Но, начиная с представления sys.стандартный ввод` реализует файл API, в том числе итератор протокол, что'ы так же, как этот:
import sys
for line in sys.stdin:
pass
Другой ответ не предлагаю в этой. Просто помните, что если вы делаете это в переводчик, вы'll необходимо сделать <и>на Ctrl</роз>-<и>г</роз> если вы'вновь на Linux или Mac, или <и>на Ctrl</роз>-<и>з</роз> на Windows (после <и>введите</КБД и GT;), чтобы отправить конец файла символ процесса. Кроме того, что ответ напрашивается печати(строки), которые добавляют '\П'
до конца - использование печати(линия, конец='')вместо этого (если в Python 2, вы'll необходимо от __будущее__ импорт print_function
).
Реальное использование-чехол для fileinput
для чтения в серии файлов.
Опираясь на все ответы, используя представление 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 ведут себя как и многие программы GNU/Unix, такие как кот
, команда grep
и СЭД
.
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. Используя стандартный ввод
echo 'foo bar' | ./above-script.py
&ампер;emsp; или короче на замену " эхо " по Здесь строки:
./above-script.py <<< 'foo bar'
2. Используя аргумент filename
echo 'foo bar' > my-file.data
./above-script.py my-file.data
3. Используя стандартный ввод
через специальный именем -
echo 'foo bar' | ./above-script.py -
Следующий чип кода поможет вам (он будет читать все с stdin блокировка до конца строки, в одну строку):
import sys
input_str = sys.stdin.read()
print input_str.split()
Читать из представления sys.как stdin, но **чтение двоичных данных в Windows**, вы должны быть очень осторожны, потому что представление sys.как stdin
открыт в текстовом режиме, и он будет поврежден \р\н-замена их с
\п`.
Решение установить режим для двоичном если Windows + на Python 2 не обнаружено, и на Python 3 Используйте представление sys.устройства stdin.буфер`.
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()
У меня проблема с решением
import sys
for line in sys.stdin:
print(line)
что если вы Don'т пройти любые данные в stdin, он будет заблокировать навсегда. Что's, почему я люблю этот ответ: проверьте, если есть какие-то данные на стандартный ввод-первых, и затем прочитать его. Вот что я делал:
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
Относительно этого:
для строки в sys.вывод:
Я просто попробовал его на Python 2.7 (после кого-то другого'ы предложение) для очень большой файл, и я не'т рекомендовать его, именно по указанным выше причинам (ничего не происходит в течение длительного времени).
Я в конечном итоге с немного более подходящие для Python решение (и оно работает на больших файлах):
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 +х cat.py` таких как:
echo Hello | ./cat.py