Базовый ввод, вывод и форматирование строк в Python

Оглавление

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

Ввод может поступать от пользователя непосредственно через клавиатуру или из внешних источников, таких как файлы или базы данных. Выходные данные могут быть выведены непосредственно в консоль или IDE, на экран через графический интерфейс пользователя (GUI) или снова во внешний источник.

В предыдущем уроке из этой вводной серии вы:

Сравнили различные парадигмы, используемые языками программирования для реализации определенной итерации
Узнали об итерациях и итераторах, двух концепциях, которые составляют основу определенной итерации в Python
Связав все это вместе, вы узнаете о циклах Python for loop

К концу этого урока вы будете знать, как:

Принимайте ввод пользователя с клавиатуры с помощью встроенной функции input()
Вывод на консоль с помощью встроенной функции print()
Форматирование строковых данных с помощью Python f-strings

Без лишних слов, давайте погрузимся!

Чтение ввода с клавиатуры

Программам часто требуется получать данные от пользователя, обычно путем ввода с клавиатуры. В Python это можно сделать с помощью input():

input([<prompt>])

Читает строку с клавиатуры. (Документация)

Функция input() приостанавливает выполнение программы, чтобы дать пользователю возможность ввести строку с клавиатуры. После нажатия пользователем клавиши Enter все введенные символы считываются и возвращаются в виде строки:

>>> user_input = input()
foo bar baz
>>> user_input
'foo bar baz'

Обратите внимание, что ваша строка возврата не включает новую строку, которая генерируется, когда пользователь нажимает клавишу Enter.

Если вы включите необязательный аргумент <prompt>, то input() отобразит его в виде подсказки, чтобы пользователь знал, что вводить:

>>> name = input("What is your name? ")
What is your name? Winston Smith
>>> name
'Winston Smith'

input() всегда возвращает строку. Если вам нужен числовой тип, то необходимо преобразовать строку в соответствующий тип с помощью встроенной функции int(), float() или complex():

 1>>> number = input("Enter a number: ")
 2Enter a number: 50
 3>>> print(number + 100)
 4Traceback (most recent call last):
 5  File "<stdin>", line 1, in <module>
 6TypeError: must be str, not int
 7
 8>>> number = int(input("Enter a number: "))
 9Enter a number: 50
10>>> print(number + 100)
11150

В приведенном выше примере выражение number + 100 в строке 3 недопустимо, поскольку number является строкой, а 100 - целым числом. Чтобы не столкнуться с этой ошибкой, в строке 8 сразу после сбора пользовательского ввода number преобразуется в целое число. Таким образом, в вычислении number + 100 в строке 10 будет два целых числа для сложения. Благодаря этому вызов print() проходит успешно.

Версия Python Примечание: Если вы работаете с кодом на Python 2.x, вы можете столкнуться с небольшой разницей в функциях ввода между Python версий 2 и 3.

raw_input() в Python 2 считывает ввод с клавиатуры и возвращает его. raw_input() в Python 2 ведет себя так же, как input() в Python 3, как описано выше.

Но в Python 2 также есть функция под названием input(). В Python 2 функция input() считывает ввод с клавиатуры, разбирает и оценивает его как выражение Python, и возвращает полученное значение.

В Python 3 нет ни одной функции, которая бы делала то же самое, что и input() в Python 2. В Python 3 можно имитировать этот эффект с помощью выражения eval(input()). Однако это представляет собой угрозу безопасности, поскольку позволяет пользователям запускать произвольный, потенциально вредоносный код.

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

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

Запись вывода в консоль

Помимо получения данных от пользователя, программа обычно должна представлять их обратно пользователю. Вы можете вывести данные программы на консоль в Python с помощью print().

Чтобы вывести объекты на консоль, передайте их в виде списка аргументов, разделенных запятыми, в print().

print(<obj>, ..., <obj>)

Выводит на консоль строковое представление каждого <obj>. (Документация)

По умолчанию print() разделяет объекты одним пробелом и добавляет новую строку в конец вывода:

>>> first_name = "Winston"
>>> last_name = "Smith"

>>> print("Name:", first_name, last_name)
Name: Winston Smith

В качестве аргумента в print() можно указать объект любого типа. Если объект не является строкой, то print() перед отображением преобразует его в соответствующее строковое представление:

>>> example_list = [1, 2, 3]
>>> type(example_list)
<class 'list'>

>>> example_int = -12
>>> type(example_int)
<class 'int'>

>>> example_dict = {"foo": 1, "bar": 2}
>>> type(example_dict)
<class 'dict'>

>>> type(len)
<class 'builtin_function_or_method'>

>>> print(example_list, example_int, example_dict, len)
[1, 2, 3] -12 {'foo': 1, 'bar': 2} <built-in function len>

Как видите, даже такие сложные типы, как списки, словари и функции могут быть выведены на консоль с помощью print().

Печать с расширенными возможностями

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

А пока вот что вам нужно знать:

Аргументы ключевых слов имеют вид <keyword>=<value>.
Любые ключевые аргументы, передаваемые в print(), должны идти в конце, после списка объектов для отображения.

В следующих разделах вы увидите, как эти аргументы ключевых слов влияют на консольный вывод, производимый print().

Разделение печатных значений

Добавление ключевого слова sep=<str> заставляет Python разделять объекты пробелами <str>, а не одиночным пробелом по умолчанию:

>>> print("foo", 42, "bar")
foo 42 bar

>>> print("foo", 42, "bar", sep="/")
foo/42/bar

>>> print("foo", 42, "bar", sep="...")
foo...42...bar

>>> d = {"foo": 1, "bar": 2, "baz": 3}
>>> for k, v in d.items():
...     print(k, v, sep=" -> ")
...
foo -> 1
bar -> 2
baz -> 3

Чтобы скомпоновать объекты без пробела между ними, укажите пустую строку ("") в качестве разделителя:

>>> print("foo", 42, "bar", sep="")
foo42bar

Вы можете использовать ключевое слово sep, чтобы указать любую произвольную строку в качестве разделителя.

Управление символом новой строки

Аргумент ключевого слова end=<str> заставляет завершать вывод <str>, а не новой строкой по умолчанию:

>>> if True:
...     print("foo", end="/")
...     print(42, end="/")
...     print("bar")
...
foo/42/bar

Например, если вы выводите значения в цикле, вы можете использовать end для того, чтобы значения выводились в одной строке, а не в отдельных строках:

>>> for number in range(10):
...     print(number)
...
0
1
2
3
4
5
6
7
8
9

>>> for number in range(10):
...     print(number, end=(" " if number < 9 else "\n"))
...
0 1 2 3 4 5 6 7 8 9

Вы можете использовать ключевое слово end, чтобы указать любую строку в качестве терминатора вывода.

Отправка вывода в поток

print() принимает два дополнительных аргумента в виде ключевых слов, оба из которых влияют на то, как функция обрабатывает поток вывода:

file=<stream>: По умолчанию print() отправляет вывод в поток по умолчанию sys.stdout, который обычно эквивалентен консоли. Аргумент file=<stream> заставляет print() вместо этого отправлять вывод в альтернативный поток, обозначенный <stream>.
flush=True: Обычно print() буферизирует свой вывод и записывает в выходной поток только периодически. flush=True указывает, что Python принудительно очищает поток вывода при каждом вызове print().

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

Использование форматированных строк

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

Во многих случаях вам потребуется более точный контроль над внешним видом данных, предназначенных для отображения. Python предоставляет несколько способов форматирования выходных строковых данных. В этом разделе вы увидите пример использования Python f-strings для форматирования строк.

Примечание: Синтаксис f-string является одним из современных способов форматирования строк. Для более подробного обсуждения вы можете ознакомиться с этими учебными пособиями:

Вы также получите более подробный обзор двух подходов к форматированию строк, f-строк и str.format(), в уроке Форматированный вывод строк в Python, который следует за этим уроком в этой вводной серии.

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

>>> name = input("What is your name? ")
What is your name? Winston

>>> age = int(input("How old are you? "))
How old are you? 24

>>> print(name)
Winston

>>> print(age)
24

Вы успешно собрали данные от пользователя и можете вывести их обратно в его консоль. Чтобы создать красиво отформатированное выходное сообщение, можно использовать синтаксис f-строки:

>>> f"Hello, {name}. You are {age}."
Hello, Winston. You are 24.

f-строки позволяют заключать имена переменных в фигурные скобки ({}), чтобы внедрить их значение в создаваемую строку. Все, что вам нужно сделать, это добавить букву f или F в начало строки.

Далее предположим, что вы хотите сообщить пользователю, сколько лет ему будет через 50 лет. Python f-строки позволяют сделать это без особых накладных расходов! Вы можете добавить любое выражение Python между фигурными скобками, и Python сначала вычислит его значение, а затем вставит его в вашу f-строку:

>>> f"Hello, {name}. In 50 years, you'll be {age + 50}."
Hello, Winston. In 50 years, you'll be 74.

Вы добавили 50 к значению age, которое вы получили от пользователя и преобразовали в целое число с помощью int() ранее. Все вычисления происходили внутри второй пары фигурных скобок в вашей f-строке. Очень круто!

Примечание: Если вы хотите узнать больше об использовании этой удобной техники форматирования строк, то можете углубиться в руководство по f-Strings Python 3.

Python f-строки - это, пожалуй, самый удобный способ форматирования строк в Python. Если вы хотите освоить только один способ, то лучше всего остановиться на f-строках Python. Однако этот синтаксис доступен только с Python 3.6, поэтому если вам нужно работать с более старыми версиями Python, то придется использовать другой синтаксис, например метод str.format() или оператор модуляции строк.

Ввод и вывод данных в Python: Заключение

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

Вы научились:

Принимайте ввод пользователя с клавиатуры с помощью встроенной функции input()
Вывод на консоль с помощью встроенной функции print()
Форматирование строковых данных с помощью Python f-strings

В следующем уроке этой вводной серии вы узнаете еще об одной технике форматирования строк и глубже погрузитесь в использование f-строк.

Вернуться на верх