Как считать несколько строк python

В Python можно получать несколько строк данных разными способами: через input(), чтение из файлов или использование sys.stdin. Каждый из подходов подходит для определённых задач – от интерактивного ввода до обработки больших текстовых потоков.

Если нужно принять несколько строк с клавиатуры, удобно использовать цикл с условием выхода, например при вводе пустой строки. Для автоматизированной обработки текстовых файлов применяют методы readlines() или итерацию по объекту файла. Такой способ особенно полезен при анализе данных или логов.

В случаях, когда строки поступают из стандартного потока, можно работать с sys.stdin для считывания произвольного количества данных, включая многострочные блоки. Этот метод часто применяют в скриптах, обрабатывающих ввод от других программ или команд оболочки.

Чтение нескольких строк с клавиатуры с помощью input()

Для ввода нескольких строк с клавиатуры можно использовать функцию input() в цикле. Этот способ подходит, когда количество строк заранее неизвестно, и пользователь завершает ввод, оставив строку пустой.

Пример:

lines = []
while True:
line = input()
if not line:
break
lines.append(line)
print(lines)

В этом примере цикл продолжается до тех пор, пока пользователь не нажмёт Enter без ввода текста. Все введённые строки сохраняются в список lines, который можно обработать позже.

Если заранее известно, сколько строк нужно считать, можно задать количество итераций:

n = int(input("Введите количество строк: "))
lines = [input() for _ in range(n)]
print(lines)

Такой подход упрощает ввод фиксированного числа строк, например при заполнении таблицы или тестовых данных. Оба метода работают одинаково во всех версиях Python начиная с 3.x.

Использование цикла для ввода неизвестного количества строк

Когда количество вводимых строк заранее неизвестно, удобно использовать цикл while с условием выхода. Такой подход позволяет завершить ввод при определённом сигнале, например пустой строке или ключевом слове.

Пример с условием окончания по пустой строке:

data = []
while True:
s = input()
if s == "":
break
data.append(s)
print(data)

Здесь программа принимает ввод построчно и добавляет каждую строку в список data. Когда пользователь нажимает Enter без текста, цикл прерывается. Этот способ удобен при работе с многострочным пользовательским вводом, например при вводе текстов, комментариев или конфигураций.

При необходимости задать собственное условие выхода можно использовать специальное слово:

data = []
while True:
s = input()
if s.lower() == "stop":
break
data.append(s)
print(data)

Такой вариант подходит, если требуется обозначить конец ввода явно, не оставляя пустых строк. Этот приём часто используется в интерактивных консольных приложениях.

Считывание нескольких строк из текстового файла

Для чтения строк из файла в Python применяется конструкция with open(), обеспечивающая автоматическое закрытие файла после завершения работы. Метод readlines() возвращает все строки в виде списка, где каждая строка оканчивается символом переноса.

with open("data.txt", "r", encoding="utf-8") as f:
lines = f.readlines()
print(lines)

Если нужно прочитать только часть файла, можно использовать срез списка:

with open("data.txt", "r", encoding="utf-8") as f:
first_five = f.readlines()[:5]
print(first_five)

При работе с большими файлами предпочтительнее считывать строки по одной, чтобы не загружать всё содержимое в память:

with open("data.txt", "r", encoding="utf-8") as f:
lines = []
for i, line in enumerate(f):
if i == 10:
break
lines.append(line.strip())
print(lines)

Сравнение основных способов чтения строк:

Выбор метода зависит от объёма данных и задачи: для анализа логов или конфигураций удобна итерация, для небольших текстов – readlines().

Чтение строк до достижения пустой строки или специального символа

Часто требуется остановить ввод при появлении пустой строки или определённого символа. Для этого используется цикл while True с проверкой условия выхода. Такой подход позволяет гибко контролировать процесс считывания.

Пример остановки по пустой строке:

lines = []
while True:
s = input()
if s == "":
break
lines.append(s)
print(lines)

В этом случае программа прекращает ввод, как только пользователь нажимает Enter без текста. Такой вариант подходит для произвольного количества строк без необходимости указывать количество заранее.

Если требуется завершать ввод по определённому символу, например по слову «END» или знаку «#», можно добавить соответствующее условие:

lines = []
while True:
s = input()
if s == "END" or s == "#":
break
lines.append(s)
print(lines)

При необходимости игнорировать лишние пробелы или регистр вводимого символа рекомендуется использовать методы strip() и lower(). Например:

if s.strip().lower() == "end":
break

Такой способ удобен для обработки пользовательских данных, где завершение ввода может быть задано в разном формате.

Сохранение считанных строк в список и их последующая обработка

После считывания строк их удобно хранить в списке для дальнейших операций: фильтрации, преобразования или анализа содержимого. Список позволяет обращаться к каждой строке по индексу и применять функции обработки текста.

Пример базового сохранения строк:

lines = []
while True:
s = input()
if not s:
break
lines.append(s)

Данные в списке можно преобразовать, например удалить лишние пробелы или привести к нижнему регистру:

cleaned = [line.strip().lower() for line in lines]

Если требуется обработать строки численно, можно превратить элементы списка в числа и выполнить вычисления:

numbers = [int(x) for x in lines if x.isdigit()]
print(sum(numbers))

Для анализа текстовых данных можно подсчитать количество строк, длину каждой строки или количество слов:

lengths = [len(line.split()) for line in lines]
print(lengths)

Примеры считывания многострочного текста с использованием sys.stdin

Для обработки многострочного ввода из стандартного потока используется модуль sys. Это удобно при работе с данными, передаваемыми через пайпы или перенаправление ввода в скрипт.

Пример построчного считывания до конца потока:

import sys
lines = []
for line in sys.stdin:
lines.append(line.strip())
print(lines)

С помощью sys.stdin.read() можно прочитать весь ввод сразу и разделить его на строки:

import sys
data = sys.stdin.read()
lines = data.splitlines()
print(lines)

Примеры практических задач:

• Подсчёт количества слов в многострочном тексте:

import sys
text = sys.stdin.read()
word_count = len(text.split())
print(word_count)

• Фильтрация строк по ключевому слову:

import sys
keyword = "error"
for line in sys.stdin:
if keyword in line:
print(line.strip())

• Обработка числовых данных, введённых построчно:

import sys
numbers = [int(line) for line in sys.stdin if line.strip().isdigit()]
print(sum(numbers))

Использование sys.stdin позволяет интегрировать Python-скрипты в конвейеры обработки данных и работать с вводом в реальном времени без ограничения на количество строк.

Вопрос-ответ:

Как считать несколько строк с клавиатуры, если заранее неизвестно их количество?

Для ввода неизвестного числа строк используют цикл while с проверкой условия выхода. Например, цикл может завершаться, когда пользователь вводит пустую строку или специальное слово. Все введённые строки обычно сохраняют в список для дальнейшей обработки.

В чём разница между readlines() и итерацией по файлу при чтении строк?

Метод readlines() считывает все строки сразу и возвращает их в виде списка, что удобно для небольших файлов. Итерация по объекту файла позволяет построчно обрабатывать данные и экономит память при работе с большими файлами, так как не загружает весь текст сразу.

Как остановить считывание строк при вводе определённого символа или слова?

В цикле можно проверять каждую строку на соответствие определённому условию. Например, если пользователь вводит «END» или «#», цикл завершается. Для надёжной проверки рекомендуется использовать strip() и lower(), чтобы игнорировать лишние пробелы и различия в регистре.

Когда стоит использовать sys.stdin для считывания многострочного текста?

Модуль sys.stdin полезен, когда ввод поступает из внешних источников или пайпов, а не напрямую с клавиатуры. Он позволяет читать данные построчно через цикл или целиком с помощью read(), а затем разделять на строки и выполнять фильтрацию, подсчёт слов или преобразование числовых значений.