Что означает эта инструкция a int input

• Главная

• Инструкции

• Python

• Оператор ввода в Python: руководство

Интерактивные возможности в Python обеспечиваются за счет ряда инструментов, одним из которых является функция input(). Ее также называют оператор ввода в Python. Главное назначение этого оператора заключается в том, чтобы принимать пользовательский ввод. Можно сказать, что он наполняет программы в Python смыслом, ведь без взаимодействия пользователя с приложением толку от последнего немного.

Эта функция работает следующим образом:

user_name = input('Введите свое имя: ')
user_age = int(input('Сколько вам лет? '))

Сначала мы просим пользователя указать имя, а затем возраст, и оба этих ввода реализуются с помощью специального оператора, который принимает введенные значения и записывает их в переменные user_name и user_age. А далее мы работаем с этими значениями. Например, можно создать условие для входа на сайт по возрасту (для этого нам понадобится перевести значение возраста в целое число при помощи инструкции int()) и написать приветствие, используя введенное имя пользователя:

if user_age < 18:
    print('Извините, но вход только для совершеннолетних')
else:
    print('Добро пожаловать на сайт,', user_name, '!')

А что будет, когда int() примет пустое значение? Например, если пользователь нажмет Enter. Допишем программу и посмотрим:

user_name = input('Введите свое имя: ')
user_age = int(input('Сколько вам лет? '))
if user_age < 18:
    print('Извините, но вход только для совершеннолетних')
else:
    print('Добро пожаловать на сайт,', user_name, '!')
    input('Нажмите Enter для перехода в меню')
    print('Добро пожаловать в меню')

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

input('Нажмите Enter для выхода')

И, если никаких строк в программе больше нет, произойдет выход. Вот полная версия программы:

user_name = input('Введите свое имя: ')
user_age = int(input('Сколько вам лет? '))
if user_age < 18:
    print('Извините, но вход только для совершеннолетних')
else:
    print('Добро пожаловать на сайт,', user_name, '!')
    input('Нажмите Enter для перехода в меню')
    print('Добро пожаловать в меню')
input('Нажмите Enter для выхода')

Если пользователь укажет разрешенный возраст, то увидит текст в блоке else, а если нет, то только в блоке if, а затем завершающее сообщение, которое высветится в конце для всех: Нажмите Enter для выхода. В программе оператор ввода используется 4 раза, причем в двух последних случаях он не принимает никаких значений, а нужен для перехода к следующей части кода и для выхода из программы.

input() в интерпретаторе

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

>>> user_name = input('Введите свое имя: ')
Введите свое имя: Вася
>>> user_age = int(input('Сколько вам лет? '))
Сколько вам лет? 18

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

Методы преобразования ввода: int(), float(), split()

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

user_age = int(input('Сколько вам лет? '))

Инструкция int() переводит значение в целочисленное, позволяя интерпретатору Python оперировать с ним как с числовым типом (цифры, введенные по умолчанию, не являются такими объектами, поэтому Питону нужна дополнительная инструкция). Добавим, что присвоение числовым переменным целочисленного значения реализуется и более длинным способом:

user_age = input('Сколько вам лет? ')
user_age = int(user_age)

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

Для преобразования ввода в рациональные числа с плавающей запятой используется инструкция float():

height = float(input('Введите свой рост в формате 1.72: '))
weight = float(input('Введите точный вес (до 0,1 кг) в формате 80.3: '))

Или другим способом:

height = input('Введите свой рост в формате 1.72: ')
height = float(height)
weight = input('Введите точный вес (до 0,1 кг) в формате 80.3: ')
weight = float(weight)

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

Инструкция split() позволяет преобразовывать вводимые слова в списки. Вот как она работает:

animals = input('Введите названия любимых животных через пробел: ').split()
print('Вот они в виде списка:', animals)

Получим такой вывод:

Введите названия любимых животных через пробел: кот собака заяц лиса медведь
Вот они в виде списка: ['кот', 'собака', 'заяц', 'лиса', 'медведь']

Боремся с ошибками ввода

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

>>> height = float(input('Введите свой рост в формате 1.72: '))
Введите свой рост в формате 1.72: 1ю72
Traceback (most recent call last):
  File "<pyshell#2>", line 1, in <module>
    height = float(input('Введите свой рост в формате 1.72: '))
ValueError: could not convert string to float: '1ю72'

Появилась ошибка, в описании которой указано, что интерпретатор не может преобразовать строку в число. Поэтому для таких случаев мы должны предусмотреть защиту. Реализуется она с помощью условной конструкции try-except:

try:
    height = float(input('Введите свой рост в формате 1.72: '))
except ValueError:
    height = float(input('Введите свой рост в указанном формате: '))

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

try:
    user_age = int(input('Сколько вам лет? '))
except ValueError:
    user_age = int(input('Введите число: '))

Однако при повторной ошибке ввода такие программы всё равно вылетят. Для максимальной устойчивости можно организовать ввод с использованием цикла:

while True:
    try:
        height = float(input('Введите свой рост в формате 1.72: '))
        break
    except ValueError:
        print('Давайте ещё разок,')
        continue
print('Спасибо!')

Мы использовали цикл while с инструкциями break и continue. Теперь программа работает так: если введенное значение корректно, цикл прерывается (действует оператор break) и программа переходит к завершающему блоку кода: print('Спасибо!'). Если же введенное значение нельзя преобразовать в число с плавающей запятой, мы обрабатываем ошибку ValueError при помощи исключения except и инструкции continue. Последняя не позволяет программе вылетать после очередной ошибки ввода, а возвращает ее к началу цикла. В результате, поскольку условие try не выполняется, программа будет предлагать пользователю ввести данные до тех пор, пока он не сделает это корректно.

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

user_name = input('Введите свое имя: ')
while True:
    try:
        user_age = int(input('Сколько вам лет? '))
        break
    except ValueError:
        print('А если серьезно?')
        continue
if user_age < 18:
    print('Извините, но вход только для совершеннолетних')
else:
    print('Добро пожаловать на сайт,', user_name, '!')
    input('Нажмите Enter для перехода в меню')
    print('Добро пожаловать в меню')
input('Нажмите Enter для выхода')

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

Ввод данных с клавиатуры осуществляется с помощью функции input(). После выполнения данной функции программа ожидает ввода данных и после нажатия «Enter» записывает их в переменную или возвращает результат на экран.

Существуют 4 вида ввода:

1. a=int(input())

Это означает, что в переменную a будет записано целое число (int — integer).

Например:

Чтобы программа начала работать, можно нажать F5 или Run Module (после этого Python предложит ее сохранить, так как он не может работать с несохраненными программами):

После этого появится примерно такое окно (окна могут различаться в зависимости от процессора, операционной системы и версии Python):

На строке, идущей после двух наборов стрелочек (в данном случае на шестой) будет мигающий курсор. Вам надо будет ввести любое целое число и нажать «Enter». После этого программа начнет работать и выведет введенное число.

2. a=float(input())

«float» означает ввод действительного числа. При вводе нецелого числа Вы должны разделить целую и дробную часть точкой. Например, «34.75»

3. a=str(input())

«str» означает ввод строки. Например, «qwerty» или «Hello, Python!» (str — string).

4. a,b=input().split()

Это означает ввод любых двух и более элементов. Скобки после «split» используются для того, чтобы задать, чем будут разделяться переменные (по умолчанию пробел). Например:

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

Результат:

В скобки после «input» можно ввести любой текст в кавычках. Например:

После начала работы у Вас откроется окно с заданным текстом:

В которое Вы можете ввести свою переменную.

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

Во введении к курсу мы узнали, что командная строка в среде разработки Visual Studio Code находится внизу на вкладке «Терминал». Именно в ней мы будем вводить данные с клавиатуры, а программа будет выводить результаты. Как было сказано ранее, мы будем писать компьютерные программы, которые принимают на вход данные, работают с ними и выводят результат на экран.

Вспомним программу из введения:

print("Привет, мир!")

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

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

Например:

• print('Привет, мир!')
• print("Привет, мир!")
• print("""Привет, мир!""")
• print("Программа выводит фразу 'Привет, мир!'")

Данные в программу могут поступать различными способами. Самый простой и привычный для пользователя — это ввод с клавиатуры. Для этого в Python используется функция input(), которая возвращает в программу введённую пользователем строку. Но данные нужно куда-то сохранить, и в этом нам помогают переменные. Переменным назначаются имена, в них записываются значения, и затем они используются в программе по мере необходимости.

Напишем программу, которая получает от пользователя строку и выводит на экран:

phrase = input()
print(phrase)

После запуска программы происходит приостановка выполнения и в терминале появляется приглашение для ввода данных:

После ввода данных необходимо нажать клавишу Enter. Программа запишет введённые данные в переменную phrase и продолжит выполнение со следующей строчки. Переменная начинает существовать в программе, когда в неё записывается какое-то значение. В момент записи значения переменной назначается тип данных, определённый в соответствии со значением.

В нашем примере в переменную phrase записывается строка, введённая пользователем. Поэтому переменной phrase назначается встроенный в язык Python тип данных str. Тип данных str используется для хранения строк, а сами строки являются упорядоченной последовательностью символов.

У функции input() можно задать параметр-строку перед вводом значения — и тогда указанный текст будет сопровождать приглашение к вводу данных:

phrase = input("Введите строку: ")
print(phrase)

Для именования переменных и правильного оформления кода существует стандарт PEP 8 (Python Enhancement Proposals), который следует соблюдать. Согласно стандарту PEP 8, имена переменных должны содержать маленькие буквы английского алфавита и символ «подчёркивание» для разделения слов в имени. Пример имён переменных по стандарту: value, first_value.

Нельзя использовать следующие однобуквенные имена переменных:

• I (большая английская i);
• l (маленькая английская L);
• O.

Эти однобуквенные имена усложнят читаемость кода, так как могут быть перепутаны между собой или с цифрами. Все стандарты PEP можно посмотреть на этой странице.

Но вернёмся к функции print(). С её помощью можно выводить сразу несколько значений. Для этого их нужно перечислить через запятую. Выведем, например, фразу Добрый день, %имя%.:

name = "Пользователь"
print("Добрый день,", name, ".")

В консоли отобразится:

Добрый день, Пользователь .

Как видим, результат работы программы не соответствует нашим ожиданиям, так как между словом «Пользователь» и точкой появился пробел. Данный пробел является символом, который по умолчанию ставится между выводимыми значениями. Вместо пробела можно указать любую другую строку, даже пустую. Для этого нужно передать в функцию print() именованный аргумент sep (англ. separator — «разделитель»). Сделаем так, чтобы вместо пробела в качестве разделителя использовалась пустая строка:

name = "Пользователь"
print("Добрый день, ", name, ".", sep="")

В консоли отобразится:

Добрый день, Пользователь.

Но в таком случае необходимые пробелы нам придётся ставить самим, а это неудобно. К счастью, в Python существует удобный и мощный инструмент для форматирования строк — f-строки. Чтобы задать f-строку, необходимо поставить букву f перед открывающей кавычкой строки. Далее f-строка записывается как единое целое, с учётом правил её форматирования, и закрывается соответствующей кавычкой:

name = "Пользователь"
print(f"Добрый день, {name}.")

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

Использование f-строк является приоритетным способом форматирования. Наряду с f-строками существует функция format(), которая также предназначена для удобного форматирования (мы рассмотрим её чуть позже). Также форматирование строк может производиться с помощью символа %. Однако данный способ форматирования является устаревшим (здесь можно почитать про него подробнее).

В строках можно применять управляющие символы, начинающиеся с символа «слеш» (). Например:

• n — переход на новую строку;
• t — табуляция;
• r — возврат каретки в начало строки;
• b — возврат каретки на один символ.

Кроме того, с помощью слеша можно экранировать символы, то есть делать их частью выводимой строки. Например, для вывода символа необходимо его экранировать самим собой:

print("\")

Подробнее об экранировании можно почитать в этом источнике.

В функции print() кроме параметра sep существует параметр end, который определяет символ в конце строки. Значение по умолчанию для него — переход на новую строку, обозначаемый как n. Если вывести строки с помощью нескольких использований функции print(), то вывод каждой из них будет осуществлён с новой строки:

print("Привет, Пользователь!")
print("Как дела?")

Привет, Пользователь!
Как дела?

Над строками можно производить следующие операции:

• сложение (конкатенация строк);
• умножение строки на целое число.

Результатом сложения строк будет новая строка, представляющая собой записанные последовательно складываемые строки (строки как бы склеиваются друг с другом, образуя новую строку).

print("Сложно" + "подчинённый")

Сложноподчинённый

При умножении строки на целое число n получается новая строка, состоящая из n дублирований исходной строки. Например, выведем 10 символов - подряд:

print("-" * 10)

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

n = 10

По аналогии создаются вещественные числовые переменные, только в качестве разделителя целой и дробной частей используется десятичный разделитель «точка»:

pi = 3.14

Для преобразования строк в числа и наоборот используются следующие функции:

• int() — преобразует строку (или вещественное число) в целое число. Дополнительно можно указать, в какой системе счисления было записано исходное число. По умолчанию используется десятичная система. При конвертации вещественного числа в целое отбрасывается дробная часть;
• float() — преобразует строку (или целое число) в вещественное число;
• str() — преобразует значения (в общем случае не только числовые) в строки.

Рассмотрим несколько примеров применения этих функций.

n_1 = "1"
n_2 = "2"
print(n_1 + n_2)
n_1 = int(n_1)
n_2 = int(n_2)
print(n_1 + n_2)

В результате выполнения программы получим:

12
3

Первый результат — результат сложения (конкатенации) двух строк. Второй — результат сложения целых чисел, которые были преобразованы из строк функцией int().

x = 3.89
x = int(x)
print(x)

Здесь программа выведет в консоли результат 3. Дробная часть после десятичного разделителя была отброшена при преобразовании в целое число.

width = "3.7"
height = "2.5"
s = float(width) * float(height)
print(s)

Программа выведет: 9.25.

А чтобы вводить целые или вещественные числа с клавиатуры, можно использовать уже знакомую нам функцию input() в сочетании с функциями int() и float():

int_number = int(input())
float_number = float(input())

Для работы с числовыми переменными доступны следующие математические операции:

• сложение — x + y;
• вычитание — x - y;
• умножение — x * y;
• деление — x / y;
• возведение в степень x ** y.

Используем все эти операции в следующей программе:

n = 25
x = 0.5

print(n + x)
print(n - x)
print(n * x)
print(n / x)
print(n ** x)

Вывод программы будет таким:

25.5
24.5
12.5
50.0
5.0

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

Например, выполнение следующего кода выведет на экран 2.0:

print(4 / 2)

Для целых чисел дополнительно доступны операции:

• целочисленное деление — x // y;
• остаток от деления — x % y.

Эти операции можно использовать, например, для получения определённых цифр числа. Получим последнюю цифру числа 1234 (то есть остаток от деления на 10):

last_digit = 1234 % 10

Для получения предпоследней цифры нужно «отрезать» последнюю цифру целочисленным делением на 10, а затем у нового числа найти последнюю цифру — уже известным нам способом:

penultimate_digit = 1234 // 10 % 10

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