Я пытаюсь выполнить некоторые задачи по коду в гольф , но все они требуют ввода информации stdin
. Как мне получить это в Python?
1474
Я пытаюсь выполнить некоторые задачи по коду в гольф , но все они требуют ввода информации stdin
. Как мне получить это в Python?
Вы можете использовать fileinput
модуль:
import fileinput
for line in fileinput.input():
pass
fileinput
будет проходить по всем строкам ввода, указанным в качестве имен файлов, указанных в аргументах командной строки, или стандартного ввода, если аргументы не предоставлены.
Примечание: line
будет содержать завершающий перевод строки; чтобы удалить это использоватьline.rstrip()
Есть несколько способов сделать это.
sys.stdin
это файл-подобный объект, для которого вы можете вызывать функции,read
илиreadlines
если вы хотите прочитать все или вы хотите прочитать все и автоматически разделить его на новую строку. (Вам нужно, чтобыimport sys
это работало.)Если вы хотите запросить ввод данных у пользователя, вы можете использовать его
raw_input
в Python 2.X и толькоinput
в Python 3.Если вы на самом деле просто хотите прочитать параметры командной строки, вы можете получить к ним доступ через список sys.argv .
Вы, вероятно, найдете эту статью Wikibook о вводе / выводе в Python также полезной ссылкой.
источник
Обратите внимание, что это будет включать символ новой строки в конце. Чтобы удалить
line.rstrip()
перевод строки в конце, используйте, как сказал @brittohalloran.источник
\r\n
окончаниями строкPython также имеет встроенные функции
input()
иraw_input()
. Смотрите документацию по Python в разделе Встроенные функции .Например,
или
источник
Вот из изучения Python :
В Unix вы можете проверить это, выполнив что-то вроде:
В Windows или DOS вы должны сделать:
источник
print(sum(chunk.count('\n') for chunk in iter(partial(sys.stdin.read, 1 << 15), '')))
. смwc-l.py
cat
здесь является излишним. Правильный вызов для систем Unix являетсяpython countlines.py < countlines.py
.readlines()
. Файловые объекты предназначены для итерации без материализации всех данных в памяти.Ты можешь использовать:
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:]
, или стандартный ввод, если не указан. Используйте как''.join(fileinput.input())
.И то
sys
и другоеfileinput
должно быть импортировано, соответственно, конечно.Быстрые
sys.stdin
примеры, совместимые с Python 2 и 3, Windows, UnixВам просто нужно
read
изsys.stdin
, например, если вы данные по конвейеру стандартного ввода:Мы видим, что
sys.stdin
в текстовом режиме по умолчанию:пример файла
Скажем, у вас есть файл,
inputs.txt
мы можем принять этот файл и записать его обратно:Более длинный ответ
Вот полная, легко воспроизводимая демонстрационная программа с использованием двух методов: встроенной функции
input
(используетсяraw_input
в Python 2) иsys.stdin
. Данные не изменены, поэтому обработка не является операцией.Для начала давайте создадим файл для входных данных:
И используя код, который мы уже видели, мы можем проверить, что мы создали файл:
Вот справка по
sys.stdin.read
Python 3:Встроенная функция,
input
(raw_input
в Python 2)Встроенная функция
input
читает от стандартного ввода до новой строки, которая удаляется (дополняетprint
, по умолчанию добавляет новую строку.) Это происходит до тех пор, пока не получит EOF (конец файла), после чего она поднимаетсяEOFError
.Таким образом, вот как вы можете использовать
input
в Python 3 (илиraw_input
в Python 2) чтение из stdin - поэтому мы создаем модуль Python, который мы называем stdindemo.py:И давайте распечатать его обратно, чтобы убедиться, что это так, как мы ожидаем:
Опять же,
input
читает до новой строки и по существу удаляет его из строки.print
добавляет новую строку. Поэтому, пока они оба изменяют ввод, их модификации отменяются. (Таким образом, они по существу являются дополнением друг друга.)И когда
input
получает символ конца файла, он вызывает EOFError, который мы игнорируем и затем выходим из программы.А в Linux / Unix мы можем передать из cat:
Или мы можем просто перенаправить файл из stdin:
Мы также можем выполнить модуль как скрипт:
Вот справка по встроенному
input
из Python 3:sys.stdin
Здесь мы делаем демонстрационный скрипт, используя
sys.stdin
. Эффективный способ перебора файловоподобного объекта - использование файловоподобного объекта в качестве итератора. Дополнительный метод для записи в стандартный вывод из этого ввода - просто использоватьsys.stdout.write
:Распечатайте его обратно, чтобы убедиться, что он выглядит правильно:
И перенаправить ввод в файл:
Гольф в команду:
Файловые дескрипторы для игры в гольф
Поскольку файловые дескрипторы для
stdin
иstdout
равны 0 и 1 соответственно, мы также можем передать ихopen
в Python 3 (не 2, и обратите внимание, что нам все еще нужна буква 'w' для записи в стандартный вывод).Если это работает в вашей системе, это сбрит больше символов.
Python 2 также
io.open
делает это, но импорт занимает гораздо больше места:Обращаясь к другим комментариям и ответам
Один комментарий предлагает
''.join(sys.stdin)
для игры в гольф, но на самом деле это дольше, чем sys.stdin.read () - плюс Python должен создать дополнительный список в памяти (вот какstr.join
работает, когда не дан список) - для контраста:Верхний ответ предполагает:
Но, поскольку
sys.stdin
реализует файловый API, включая протокол итератора, это то же самое, что и это:Другой ответ действительно предлагает это. Просто помните, что если вы делаете это в интерпретаторе, вам нужно Ctrl- dесли вы работаете в Linux или Mac или Ctrl- zв Windows (после Enter), чтобы отправить символ конца файла процессу. Кроме того, этот ответ предлагает
print(line)
- который добавляет'\n'
в конце - использоватьprint(line, end='')
вместо этого (если в Python 2 вам понадобитсяfrom __future__ import print_function
).Реальный вариант использования
fileinput
- для чтения в серии файлов.источник
Ответ, предложенный другими:
очень прост и питоничен, но следует отметить, что сценарий будет ждать до EOF, прежде чем начать итерацию по строкам ввода.
Это означает, что
tail -f error_log | myscript.py
не будет обрабатывать строки, как ожидалось.Правильный сценарий для такого варианта использования будет:
ОБНОВЛЕНИЕ
Из комментариев было убрано, что только на python 2 может быть задействована буферизация, так что вы в конечном итоге ожидаете заполнения буфера или EOF перед вызовом печати.
источник
for line in sys.stdin:
Картина не ждать EOF. Но если вы тестируете очень маленькие файлы, ответы могут быть помещены в буфер. Протестируйте с большим количеством данных, чтобы увидеть, что он читает промежуточные результаты.print line
не проснулся в 3.1.3, ноprint(line)
делает.for line in sys.stdin:
не "блокировать до EOF". В Python 2 есть ошибка опережающего чтения, которая задерживает строки до тех пор, пока соответствующий буфер не будет заполнен. Это проблема буферизации, не связанная с EOF. Чтобы обойти это, используйтеfor line in iter(sys.stdin.readline, ''):
(используйтеio.open()
для обычных файлов). Вам не нужно это в Python 3.Это отобразит стандартный ввод в стандартный вывод:
источник
Основываясь на использовании всех ответов
sys.stdin
, вы также можете сделать что-то вроде следующего, чтобы прочитать из файла аргументов, если существует хотя бы один аргумент, и в противном случае вернуться к stdin:и использовать его как либо
или
или даже
Это заставит ваш скрипт на Python вести себя как многие программы GNU / Unix, такие как
cat
,grep
иsed
.источник
argparse
это простое решениеПример совместим с обеими версиями Python 2 и 3:
Вы можете запустить этот скрипт разными способами:
1. Использование
stdin
или короче, заменив
echo
на здесь строки :2. Использование аргумента имени файла
3. Использование
stdin
через специальное имя файла-
источник
add_argument('--in'
а затем направить к сценарию и добавить--in -
в командную строку. PSin
не очень хорошее имя для переменной / атрибута.in
не просто плохое имя для переменной, это недопустимо.args.in.read()
вызовет ошибку InvalidSyntax из-заin
зарезервированного ключевого слова. Можно просто переименовать так,infile
как это делают документы на python argparse: docs.python.org/3/library/…Вам поможет следующий фрагмент кода (он будет считывать все блокирующие stdin
EOF
в одну строку):источник
Я очень удивлен, что никто не упомянул этот хак до сих пор:
в python2 вы можете отбросить
set()
вызов, но это будет слово в любом случаеисточник
readlines
это разделение на строки, а затемjoin
снова? Вы можете просто написатьprint(sys.stdin.read())
write
возвращаетсяNone
, и размер набора никогда не будет больше 1 (=len(set([None]))
)Попробуй это:
и проверьте это с:
источник
Вы можете читать из stdin и затем сохранять входные данные в «data» следующим образом:
источник
data = sys.stdin.read()
без проблем повторных конкатенаций строк.Читайте
sys.stdin
, но чтобы читать двоичные данные в Windows , вам нужно быть очень осторожным, потомуsys.stdin
что они открыты в текстовом режиме и будут повреждены,\r\n
заменив их\n
.Решение состоит в том, чтобы установить режим в двоичный режим, если обнаружен Windows + Python 2, и использовать Python 3
sys.stdin.buffer
.источник
Я использую следующий метод, он возвращает строку из стандартного ввода (я использую его для анализа JSON). Он работает с pipe и подсказкой в Windows (пока не тестировался в Linux). При запросе два разрыва строки указывают на конец ввода.
источник
Проблема у меня с решением
в том, что если вы не передадите данные в stdin, он будет заблокирован навсегда. Вот почему мне нравится этот ответ : сначала проверьте, есть ли какие-то данные на stdin, а затем прочитайте их. Это то, что я в итоге сделал:
источник
select
вызове ввод почти никогда не будет «готов» ; или вы также можете столкнуться с проблемами, если stdin подключен к файлу на медленном носителе (сеть, компакт-диск, лента и т. д.). Вы сказали, что «если вы не передадите данные в stdin, они будут заблокированы навсегда». это проблема , но я бы сказал, что это особенность . Большинство программ CLI (напримерcat
) работают таким образом, и они ожидаются. EOF - единственная вещь, от которой вы должны зависеть, чтобы определить конец ввода.У меня были некоторые проблемы при получении этого для работы через сокеты, переданные по каналу. Когда сокет закрылся, он начал возвращать пустую строку в активном цикле. Так что это мое решение (которое я тестировал только в Linux, но надеюсь, что оно работает во всех других системах)
Поэтому, если вы начнете прослушивать сокет, он будет работать правильно (например, в bash):
И вы можете позвонить с помощью telnet или просто указать браузер на localhost: 12345
источник
В соответствии с этим:
for line in sys.stdin:
Я только что попробовал это на python 2.7 (следуя чьему-либо предложению) для очень большого файла, и я не рекомендую его именно по причинам, указанным выше (в течение долгого времени ничего не происходит).
Я получил немного более питонное решение (и оно работает с большими файлами):
Затем я могу запустить скрипт локально как:
источник
sys.stdin
качестве аргумента командной строки сценарий.sys.stdin
в качестве аргумента командной строки сценарий? Аргументы - это строки, а потоки - это файловые объекты, они не одинаковы.sys.stdin
этоДля Python 3 это будет:
Это в основном простая форма cat (1), так как она не добавляет символ новой строки после каждой строки. Вы можете использовать это (после того, как Вы отметили исполняемый файл, используя
chmod +x cat.py
такие как:источник
Существует,
os.read(0, x)
который читает xbytes от 0, который представляет стандартный ввод. Это небуферизованное чтение, более низкий уровень, чем sys.stdin.read ()источник
При использовании
-c
команды, как хитрый способ, вместо чтенияstdin
(и в некоторых случаях более гибкого) вы можете передать команду сценария оболочки также вашей команде python, поместив команду sell в кавычки в скобках, начинающихся с$
знака.например
Это будет считать количество строк из файла истории Goldendict.
источник