Как пишется int input

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

Python, будучи медленным относительно таких языков, как C или Java, предлагает продвинутые инструменты для получения, анализа и обработки данных от конечного пользователя.

В этом материале речь пойдет о том, какие функции Python можно использовать для этих целей.

Для получения информации с клавиатуры в Python есть функции input() или raw_input() (о разнице между ними чуть позже). У них есть опциональный параметр prompt, который является выводимой строкой при вызове функции.

Когда input() или raw_input() вызываются, поток программы останавливается до тех пор, пока пользователь не введет данные через командную строку. Для ввода нужно нажать Enter после завершения набора текста. Обычно Enter добавляет символ новой строки (n), но не в этом случае. Введенная строка просто будет передана приложению.

Интересно, что кое-что поменялось в принципе работе функции между Python 2 и Python 3, что отразилось в разнице между input() и raw_input(). Об этом дальше.

Сравнение функций input и raw_input

Разница между этими функциями зависит от версии Python. Так, в Python 2 функция raw_input() используется для получения ввода от пользователя через командную строку, а input() оценивает ее и попробует запустить как код Python.

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

Взгляните на пример функции raw_input в Python 2.

# Python 2

txt = raw_input("Введите что-нибудь, чтобы проверить это: ")
print "Это то, что вы только что ввели?", txt

Вывод

Введите что-нибудь, чтобы проверить это: Привет, мир!

Это то, что вы только что ввели? Привет, мир!

А вот как она работает в Python 3

# Python 3

txt = input("Введите что-нибудь, чтобы проверить это: ")
print("Это то, что вы только что ввели?", txt)

Вывод

Введите что-нибудь, чтобы проверить это: Привет, мир 3!

Это то, что вы только что ввели? Привет, мир 3!

Дальше в материале будет использоваться метод input из Python 3, если не указано другое.

Строковый и числовой ввод

По умолчанию функция input() конвертирует всю получаемую информацию в строку. Прошлый пример продемонстрировал это.

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

# Ввод запрашивается и сохраняется в переменной
test_text = input ("Введите число: ")

# Преобразуем строку в целое число.
# функция float() используется вместо int(),
# для преобразования пользовательского ввода в десятичный формат,  
test_number = int(test_text)

# Выводим в консоль переменную
print ("Введенное число: ", test_number)

Вывод

Введите число: 13
Введенное число: 13

Того же можно добиться и таким образом:

test_number = int(input("Введите число: "))

Здесь сразу после сохранения ввода происходит преобразование и присваивание значения переменной.

Нужно лишь отметить, что если пользователь ввел не целое число, то код вернет исключение (даже если это число с плавающей точкой).

Обработка исключений ввода

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

Вот такой код считается небезопасным:

test2word = input("Сколько вам лет? ")
test2num = int(test2word)
print("Ваш возраст ", test2num)

Запустим его и введем следующее:

Сколько вам лет? Пять

При вызове функции int() со строкой Пять появится исключение ValueError, и программа остановит работу.

Вот как можно сделать код безопаснее и обработать ввод:

test3word = input("Введите свое счастливое число: ")

try:
    test3num = int(test3word)
    print("Это правильный ввод! Ваше счастливое число: ", test3num)
except ValueError:
    print("Это не правильный ввод. Это не число вообще! Это строка, попробуйте еще раз.")

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

Вот так будет выглядеть вывод с исключением.

Введите свое счастливое число: Семь
Это не правильный ввод. Это не число вообще! Это строка, попробуйте еще раз.

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

Полный пример

# Создадим функцию для демонстрации примера
def example():

    # Бесконечный цикл, который продолжает выполняться  
    # до возникновения исключения
    while True:
        test4word = input("Как вас зовут? ")

        try:
            test4num = int(input("Сколько часов вы играете на своем мобильном телефоне?" ))

        # Если полученный ввод не число, будет вызвано исключение
        except ValueError:
            # Цикл будет повторяться до правильного ввода
            print("Error! Это не число, попробуйте снова.")

        # При успешном преобразовании в целое число,  
        # цикл закончится.
        else:
            print("Впечатляет, ", test4word, "! Вы тратите", test4num*60, "минут или", test4num*60*60, "секунд на игры в своем телефоне!")
            break

# Вызываем функцию
example()

Вывод:

Как вас зовут? Александр
Сколько часов вы играете на своем мобильном телефоне? 3
Впечетляет, Александр! Вы тратите 180 минут или 10800 секунд на игры в своем телефоне!

Выводы

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

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

Ввод в Python

В Питоне есть функция input(), предназначенная для считывания данных, введённых пользователем в консоль с клавиатуры.

Когда вызывается input(), поток выполнения программы останавливается до тех пор, пока пользователь не произведет ввод в терминал.

Для завершения ввода пользователь должен нажать «Enter».

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

переменная = input()
print('переменная:', переменная)
print(type(переменная))

# Вывод:

2

переменная: 2

<class 'str'>

  

Преобразование вводимых данных

Если Вам необходимо использовать данные, введённые пользователем не как строковые, Вам придётся самостоятельно преобразовать тип данных. Мы уже рассказывали о преобразовании типов, но давайте освежим знания.

Input() в int

Если Вам нужно получить целое число, используйте функцию int():

переменная = input()
print('переменная:', переменная)
print(type(переменная))
новая_переменная = int(переменная)
print('новая_переменная:', новая_переменная)
print(type(новая_переменная))
# Вывод:

3

переменная: 3

<class 'str'>

новая_переменная: 3

<class 'int'>

  

То же самое можно сделать гораздо короче, используя мощь Питона:

print('переменная: {}'.format(переменная := int(input())), type(переменная), sep='n')
# Вывод:
10
переменная: 10
<class 'int'>

  

Input() в float

Если нужно получить число с плавающей точкой (не целое), примените  функцию float().

переменная = float(input())
print('переменная:', переменная)
print(type(переменная))
# Вывод:

5

переменная: 5.0

<class 'float'>

  

Input() в list (список)

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

переменная = input().split()
print(переменная)
print(type(переменная))
# Вывод:

1 2 3

['1', '2', '3']

<class 'list'>

  

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

переменная = input().split(',')
print(переменная)
print(type(переменная))
# Вывод:

1,2,3

['1', '2', '3']

<class 'list'>

  

Во обоих случаях элементы всё равно имеют строковый тип:

переменная = input().split(',')
print(переменная)
print(type(переменная))
print(list(map(type, переменная)))
# Вывод:

1,2,3

['1', '2', '3']

<class 'list'>

[<class 'str'>, <class 'str'>, <class 'str'>]

  

Если же Вам нужно преобразовать и их, можно снова использовать функцию преобразования типов в связке с циклом:

переменная = list()
for element in input().split():
    переменная.append(complex(element))
print(переменная)
print([type(num) for num in переменная])
# Вывод:

999 333 666

[(999+0j), (333+0j), (666+0j)]

[<class 'complex'>, <class 'complex'>, <class 'complex'>]

  

Можно так же использовать списковое включение, что выглядит лаконичнее:

переменная = [complex(element) for element in input().split()]
print(переменная)
print([type(num) for num in переменная])
# Вывод:

999 333 666

[(999+0j), (333+0j), (666+0j)]

[<class 'complex'>, <class 'complex'>, <class 'complex'>]

  

Но, пожалуй самый «чистый» и производительный способ сделать это, расположен в самых недрах функционального программирования – функция высшего порядка:

переменная = list(map(complex, input().split()))
print(переменная)
print([type(num) for num in переменная])
# Вывод:

999 333 666

[(999+0j), (333+0j), (666+0j)]

[<class 'complex'>, <class 'complex'>, <class 'complex'>]

  

input() в dict (словарь)

К сожалению, попытки простого преобразования данных input() в dict приводят лишь к извращениям:

переменная = dict()
введённые_данные = input().split()
for i, element in enumerate(введённые_данные):
    if i % 2 == 0 and len(введённые_данные) - i > 1:
        переменная[element] = complex(введённые_данные[i + 1])
print(переменная)
print('Тип ключей:', [type(num) for num in переменная])
print('Тип значений:', [type(num) for num in переменная.values()])
# Вывод:

первый_элемент 12 второй_элемент 54

{'первый_элемент': (12+0j), 'второй_элемент': (54+0j)}

Тип ключей: [<class 'str'>, <class 'str'>]

Тип значений: [<class 'complex'>, <class 'complex'>]

  

Но, как видите, это работает.

Ввод в несколько переменных

Если необходимо заполнить одним вводом с клавиатуры сразу несколько переменных, воспользуйтесь распаковкой:

переменная, ещё_одна_переменная, последняя_переменная = input().split()

print('Переменная:', переменная)
print('Ещё_одна_переменная:', ещё_одна_переменная)
print('Последняя_переменная:', последняя_переменная)
# Вывод:

Не_верь Не_бойся Не_проси

Переменная: Не_верь

Ещё_одна_переменная: Не_бойся

Последняя_переменная: Не_проси

  

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

• если введенных значений больше чем переменных, Вы получите ошибку – ValueError: too many values to unpack (expected 3);
• если введенных значений меньше чем переменных, Вы получите ошибку – ValueError: not enough values to unpack (expected 3, got 2);

Этого можно избежать, если использовать ещё одну хитрость: распаковку слева))

переменная, ещё_одна_переменная, *остальные_элементы = input().split()
print('Переменная:', переменная)
print('Ещё_одна_переменная:', ещё_одна_переменная)
print('Остальные_элементы:', остальные_элементы)
# Вывод:

Не_верь Не_бойся Не_проси И_успокойся

Переменная: Не_верь

Ещё_одна_переменная: Не_бойся

Остальные_элементы: ['Не_проси', 'И_успокойся']

  

Параметр prompt

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

print('Введите что-нибудь: ')
input()
# Вывод:

Введите что-нибудь:

что-нибудь

  

К счастью, эту возможность обеспечивает сама функция input() – Вы можете передать сообщение для пользователя как позиционный аргумент функции (или по имени параметра promt, но так никто не делает) и сообщение будет отображено на экране:

input('Введите что-нибудь: ')
# Вывод:

Введите что-нибудь: что-нибудь

  

Обработка исключений ввода

Древняя компьютерная мудрость гласит: «не доверяй пользователю». Дело в том, что пользовательский ввод – это место, через которое информация попадает внутрь программы. Здесь можно провести аналогию со ртом, через который пища попадает в организм. Вы ведь не всё подряд засовываете в рот? Очень надеемся, что так и есть!

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

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

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

Давайте немного повоюем с воображаемым программистом. Вот код, который доверчиво ожидает от пользователя ввода числа от 1 до 100:

from math import sqrt

переменная = input('Введите число от 1 до 100: ')
переменная = int(переменная)
print('Корень Вашего числа равен: ', sqrt(переменная))
# Вывод:

Введите число от 1 до 100: шесть

Traceback (most recent call last):

File "C:UsersivandAppDataRoamingJetBrainsPyCharm2021.2scratchesscratch.py", line 4, in <module>

переменная = int(переменная)

ValueError: invalid literal for int() with base 10: 'шесть'

 

Process finished with exit code 1

  

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

from math import sqrt

переменная = input('Введите число от 1 до 100: ')
while True:
    for i in переменная:
        if i.isalpha():
            print('Введите число (ЦИФРАМИ)!')
            переменная = input('Введите число от 1 до 100: ')
            break
    else:
        break

переменная = int(переменная)
print('Корень Вашего числа равен: ', sqrt(переменная))
# Вывод:

Введите число от 1 до 100: шесть

Введите число (ЦИФРАМИ)!

Введите число от 1 до 100: ,,

Traceback (most recent call last):

File "C:UsersivandAppDataRoamingJetBrainsPyCharm2021.2scratchesscratch.py", line 13, in <module>

переменная = int(переменная)

ValueError: invalid literal for int() with base 10: ',,'

 

Process finished with exit code 1

  

Что ж, добавим проверку, что вводится именно число:

from math import sqrt

переменная = input('Введите число от 1 до 100: ')
while True:
    for i in переменная:
        if not i.isnumeric():
            print('Введите число (ЦИФРАМИ)!')
            переменная = input('Введите число от 1 до 100: ')
            break
    else:
        break

переменная = int(переменная)
print('Корень Вашего числа равен: ', sqrt(переменная))
# Вывод:

Введите число от 1 до 100: 20.5

Введите число (ЦИФРАМИ)!

Введите число от 1 до 100: Ⅻ

Traceback (most recent call last):

File "C:UsersivandAppDataRoamingJetBrainsPyCharm2021.2scratchesscratch.py", line 13, in <module>

переменная = int(переменная)

ValueError: invalid literal for int() with base 10: 'Ⅻ'

 

Process finished with exit code 1

  

Всё, хватит это терпеть! Проверяем, что пользователь вводит именно целое число:

from math import sqrt

переменная = input('Введите число от 1 до 100: ')
while True:
    for i in переменная:
        if not i.isdigit():
            print('Введите ЧИСЛО (ТОЛЬКО ЦИФРЫ)!!!')
            переменная = input('Введите число от 1 до 100: ')
            break
    else:
        break

переменная = int(переменная)
print('Корень Вашего числа равен: ', sqrt(переменная))
# Вывод:

Введите число от 1 до 100: Ⅻ

Введите ЧИСЛО (ТОЛЬКО ЦИФРЫ)!!!

Введите число от 1 до 100: 1000000

Корень Вашего числа равен:  1000.0

 

Process finished with exit code 0

  

Здесь, формально, всё прошло гладко, но введённое значение не входит в требуемый диапазон. Как видите, это не так просто. Ещё один способ – принимать любой пользовательский ввод и потом «ловить» ошибки внутри программы:

from math import sqrt

while True:
    переменная = input('Введите число от 1 до 100: ')
    try:
        переменная = int(переменная)
    except:
        print('Введите ЧИСЛО (ТОЛЬКО ЦИФРЫ)!!!')
    else:
        break

print('Корень Вашего числа равен: ', sqrt(переменная))
# Вывод:

Введите число от 1 до 100: шесть

Введите ЧИСЛО (ТОЛЬКО ЦИФРЫ)!!!

Введите число от 1 до 100: 6

Корень Вашего числа равен:  2.449489742783178

 

Process finished with exit code 0

  

Но обработка исключений не такая простая тема, как может показаться (подробнее можете ознакомиться с исключениями в нашей статье).

К тому же, этот подход не защищает от направленных атак:

while True:
    переменная = input('Введите выражение: ')
    try:
        print('Результат выражения:', eval(переменная))
    except:
        print('Введите выражение на языке Python!')
    else:
        break

# Вывод:

Введите выражение: Попытка атаки

Введите выражение на языке Python!

Введите выражение: 'Я' + ' загружаю' + ' страшный' + ' вирус!'

Результат выражения: Я загружаю страшный вирус!

  

Эмуляция терминала с использованием функции input().

Для того, чтоб продемонстрировать мощь этой функции, приведём отрывок кода из официальной документации:

def run_user_code(envdir):
    source = input(">>> ")
    try:
        # Выполнение введенного кода с клавиатуры
        exec(source, envdir)
    except Exception as e:
        print("Exception in user code:")
        print("-"*60)
        print(str(e))
        print("-"*60)

# словарь для хранения введенных переменных
envdir = {}

while True:
    run_user_code(envdir)
# Вывод:

>>> переменная = 2

>>> вторая_переменная = 3

>>> print('сумма переменных равна:', переменная + вторая_переменная)

сумма переменных равна: 5

>>> 1 / 0

Exception in user code:

------------------------------------------------------------

division by zero

------------------------------------------------------------

>>>

  

Практическая работа

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

«Здравствуйте, < фамилия > < имя > < отчество >

1. Напишите программу, которая предлагала бы пользователю решить пример 666 * 333 // 54. Потом выводила бы на экран правильный ответ и ответ пользователя.
2. Запросите у пользователя три числа и два арифметических знака. Выведите результат последовательного выполнения данных операций.

• Главная

• Инструкции

• 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 лет), но, чтобы заставить пользователей вводить реалистичные данные, потребуется использовать диапазоны значений. Впрочем, это выходит за рамки данной статьи, а с вводом и с исключением ошибок ввода мы уже разобрались.

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

Во введении к курсу мы узнали, что командная строка в среде разработки 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

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

• Базовые конструкции языка
• Переменные, оператор присваивания, типы данных
• Функции input и print ввода/вывода
• Арифметические операции
• Условный оператор if и составные условия
• Операторы циклов, операторы break и continue

• Главная
• Основы Python
• Базовые конструкции языка

w = float(input())
h = float(input())
p = 2*(w+h)
print(p)

w = float(input("Введите ширину: "))
h = float(input("Введите длину: "))

print(1)
print(1, 2)
print(1, 2, 3)

print(1, 2, 3, sep=",")
print(1, 2, 3, sep="-")
print(1, 2, 3, sep="***")

print(1, 2, 3, sep=",", end=':')
print(1, 2, 3, sep="-", end='--end--n')
print(1, 2, 3, sep="***")

name = "Федор"
print("Имя", name, sep=":")

name = "Федор"; age = 18
print("Имя %s, возраст %d"%(name, age))