Python ошибка ввода данных

• Главная

• Инструкции

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

В этом руководстве мы рассмотрим как используется и для чего нужны исключения (exception) в Python. Так же рассмотрим как использовать конструкцию try-except.

Введение

Для управления ошибками, которые появляются в программе, Python использует особые объекты, называемые исключениями (exceptions).

Каждый раз, когда происходит ошибка, из-за которой Python не знает, что делать дальше, создается объект исключения. Если напишете код, обрабатывающий исключение, то приложение не завершит работу, а продолжит выполнение. Не написав обработку исключения программа остановится и покажет трассировку, которая включает в себя отчет об ошибке.

Примеры вызова exception

Рассмотрим популярные примеры вызов исключений.

Получение доступа к индексу за пределами списка

num = [33,34, 35, 36]
num[7]

IndexError: list index out of range

Конвертирование неподходящего типа

dict(num)

TypeError: cannot convert dictionary update sequence element #0 to a sequence

Обращение к несуществующей переменной

print(city)

NameError: name 'city' is not defined

Смешивание типов без преобразования

a = 'test string'
a + 10

TypeError: can only concatenate str (not "int") to str

Типы исключений

• SyntaxError — Ошибка в синтаксисе программы
• NameError — Ошибка обращения к несуществующей переменной
• AttributeError — Ссылка на атрибут не работает
• TypeError — Операнд не имеет правильного типа
• ValueError — Неверный тип у значения переменной
• IOError — Ошибка в подсистеме системе ввода вывода
• ZeroDivisionError — Ошибка деления на ноль

Ознакомиться с полным списком встроенных исключений можно в официальной документации.

first = int(input("Напишите любое целое число: "))
second = int(input("Введите еще одно число: "))

print(first/second)

Этот пример кода выполняет деление одного числа на другое. Чтобы продемонстрировать ошибку, предположим что пользователь вводит 10 и 0 в качестве первого и второго чисел соответственно, Python на это возбуждает исключение ZeroDivisionError:

Напишите любое целое число: 10
Введите еще одно число: 0

ZeroDivisionError: division by zero

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

Язык имеет встроенную конструкцию для работы с исключениями. Обработка происходит с помощью блока try-except.

Блок try-except заставляет Python выполнить код внутри него, но также говорит Python, что делать в случае если будет вызвано исключение. Когда используете try-except, программа будет продолжать работать, даже если возникнут какие-нибудь ошибки. Вместо Traceback, который сбивает с толку, пользователи увидят дружественные сообщения об ошибках, но их нужно заранее предусмотреть.

try:
     first = int(input("Напишите любое целое число: "))
     second = int(input("Введите еще одно число: "))
     print(first/second)
except:
     print("Ошибка ввода данных")

Давайте введем тот же набор данных что и посмотрим что будет

Напишите любое целое число: 10
Введите еще одно число: 0
Ошибка ввода данных

Ввод строки вместо числа

Напишите любое целое число: 10
Введите еще одно число: ноль
Ошибка ввода данных

В предыдущем примере деление на 0 приводило к исключению ZeroDivisionError, но когда ввели строковое значение переменной и попробовали на него разделить число сработало новое исключение ValueError.

Проверка с корректным вводом.

Напишите любое целое число: 6
Введите еще одно число:  2
3

В этом примере не происходит вызова исключений т.к данные введены и обработаны корректно.

Обработка конкретных исключений

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

В нашем случае можно поймать и обработать исключение ZeroDivisionError.

try:
     first = int(input("Напишите любое целое число: "))
     second = int(input("Введите еще одно число: "))
     print(first/second)
except ZeroDivisionError:
     print("Разделить число на ноль - невозможно!")

Попробуем разделить на ноль и посмотрим результат

Напишите любое целое число: 4
Введите еще одно число: 0

Разделить число на ноль - невозможно!

А что будет если ввести строку?

Напишите любое целое число: 4
Введите еще одно число: один

ValueError: invalid literal for int() with base 10: 'один'

Python вызывает исключения, потому что мы не написали код для этого конкретного исключения — ValueError.

Обработка нескольких исключений

Конструкция обработки исключений дает возможность обрабатывать каждый тип ошибки отдельно, пример ниже дополнительно обрабатывает ошибку ValueError

try:
     first = int(input("Напишите любое целое число: "))
     second = int(input("Введите еще одно число: "))
     print(first/second)
except ZeroDivisionError:
     print("Разделить число на ноль - невозможно!")
except ValueError:
     print("Неправильный тип переменной")

Использование оператора finally

В конструкции try-except есть дополнительный, но не обязательный оператор finally. Код внутри этого блока выполняется перед завершением конструкции try-except, вне зависимости от того какие исключения были обработаны, а какие нет.

try:
     first = int(input("Напишите любое целое число: "))
     second = int(input("Введите еще одно число: "))
     print(first/second)
except ZeroDivisionError:
     print("Разделить число на ноль - невозможно!")
except ValueError:
     print("Неправильный тип переменной")
finally:
     print("Работа программы завершена")

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

Заключение

Сегодня мы рассмотрели как используется и для чего нужны исключения в Python. Если у вас есть дополнительные вопросы, не стесняйтесь задавать их в комментариях.

Введение в тему

Зачастую возникают ситуации, когда программа или скрипт работают не так, как задумывал программист. Чаще всего это бывает из-за ввода неожиданных данных. Для обработки таких ситуаций в языке программирования Python есть конструкция try except else finally. Это называется обработкой исключений и позволяет контролировать аварийные случаи. Об этом мощном инструменте мы и поговорим в данном уроке.

Что такое исключения

Работа программиста во многом связана с возникающими в коде ошибками. Их приходится находить и исправлять. Особенно опасны так называемые гейзенбаги – ошибки, которые сложно воспроизвести. Так же существуют скрытые ошибки, их ещё можно назвать логическими. Ещё есть ошибки, которые и вовсе не зависят от программы. Представьте, у Вас есть программа-скрапер, которая автоматически скачивает картинки из соцсети. Заходит она на очередную страницу… А сервер сети поломался. Программа выдаст ошибку.

Если говорить именно о Питоне, то сложность ещё и в том, что это не компилируемый, а интерпретируемый язык, то есть код выполняется «на лету», строка за строкой. Это означает, что у Пайтон-программиста нет возможности отловить ошибки на этапе компиляции. Ещё одна сложность заключается в том, что Python – язык со строгой, но динамической типизацией. Частично это решается в последних версиях языка средством под названием «аннотирование типов», но полностью проблемы не устраняет.

И так, существуют следующие виды ошибок:

• Синтаксические – когда программист нарушает правила самого языка, к примеру, допускает опечатку в ключевом слове;
• Логические – когда в коде используется не верная логика;
• Ввода – когда программист предполагал от пользователя ввода одних данных, а введены другие. К примеру, создатель сайта задумывал, что число в форме будет указано с использованием точки в качестве разделителя, а пользователь ввёл «3,14». Именно этот вид ошибок – излюбленная лазейка хакеров.

Синтаксические ошибки – самые простые, поскольку интерпретатор сам сообщит Вам о них при попытке запустить скрипт.

Простой пример, напечатали команду print с большой буквы:

Print('Hello World!')
# Вывод

Traceback (most recent call last):

File "C:/Users/ivand/PycharmProjects/pythonProject/main.py", line 1, in <module>

Print('Hello World!')

NameError: name 'Print' is not defined

 

Process finished with exit code 1


  

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

from random import randint

random_list = 5
sorted_list = []
for i in range(random_list):
sorted_list.append(randint(1, 99))
print(sorted_list)

for i in range(random_list - 1):
for j in range(random_list - i - 1):
if sorted_list[j] > sorted_list[j + 1]:
sorted_list[j] = sorted_list[j + 1]

print(sorted_list)
# Вывод:

 

[95, 57, 16, 29, 82]

[16, 16, 16, 29, 82]


  

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

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

x_var = input('Введите число и мы его разделим на 10 n')
print('Результат деления:', float(x_var) / 10)
# Вывод:

 

Введите число и мы его разделим на 10

3,14

Traceback (most recent call last):

File "C:/Users/ivand/PycharmProjects/pythonProject/main.py", line 2, in <module>

print('Результат деления:', float(x_var) / 10)

ValueError: could not convert string to float: '3,14'


  

Как вы видите, интерпретатор «выбрасывает» исключение «ValueError» — ошибка значения и останавливает выполнение кода.

Перехват исключений

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

x_var = input('Введите число и мы его разделим на 10 n')
try:
print('Результат деления:', float(x_var) / 10)
except ValueError:
print('Вы ввели число с запятой, а надо с точкой')
print('Программа завершена')
# Вывод:

Введите число и мы его разделим на 10

3,14

Вы ввели число с запятой, а надо с точкой

Программа завершена

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

Несколько блоков except

Можно использовать несколько блоков except и обрабатывать в каждом блоке отдельный вид ошибки. Немного перепишем программу из предыдущего примера:

x_var = input('Введите число и мы разделим на него 10 n')
try:
print('Результат деления:', 10 / float(x_var))
except ValueError:
print('Вы ввели число с запятой, а надо с точкой')
except ZeroDivisionError:
print('Вы ввели ноль, но на него делить нельзя')
print('Программа завершена')
# Вывод:

Введите число и мы разделим на него 10

0

Вы ввели ноль, но на него делить нельзя

Программа завершена


  

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

x_var = input('Введите число и мы разделим на него 10 n')
try:
Print('Результат деления:', 10 / float(x_var))
except ValueError:
print('Вы ввели число с запятой, а надо с точкой')
except ZeroDivisionError:
print('Вы ввели ноль, но на него делить нельзя')
except:
print('Не знаю что, но что-то точно пошло не так')
print('Программа завершена')
# Вывод:

Введите число и мы разделим на него 10

10

Не знаю что, но что-то точно пошло не так

Программа завершена


  

Вложенные блоки и else

Блоки try-except можно вкладывать друг в друга, если в этом есть необходимость.

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

x_var = input('Введите число и мы разделим на него 10 n')
try:
result = 10 / float(x_var)
try:
print('Результат деления:', result)
except:
print('Не знаю что, но что-то точно пошло не так')
else:
print('Полёт нормальный')
except ValueError:
print('Вы ввели число с запятой, а надо с точкой')
except ZeroDivisionError:
print('Вы ввели ноль, но на него делить нельзя')
else:
print('Программа выполнена без ошибок')
print('Программа завершена')
# Вывод:

Введите число и мы разделим на него 10

10

Результат деления: 1.0

Полёт нормальный

Программа выполнена без ошибок

Программа завершена


  

Кстати, здесь допущена логическая ошибка. Найдёте?

Finally

Встречаются ситуации, когда необходимо выполнить какую-то часть кода в независимости от того, было исключение или нет. Для этого существует блок finally:

try:
result = 10 / float(x_var)
try:
Print('Результат деления:', result)
except:
print('Не знаю что, но что-то точно пошло не так')
else:
print('Полёт нормальный')
except ValueError:
print('Вы ввели число с запятой, а надо с точкой')
except ZeroDivisionError:
print('Вы ввели ноль, но на него делить нельзя')
finally:
print('Программа завершена')
# Вывод:

Введите число и мы разделим на него 10

10

Не знаю что, но что-то точно пошло не так

Программа завершена


  

Управление исключениями

В Пайтоне есть возможность создавать свои виды исключений. Ниже мы рассмотрим как это делать, а ещё такую важную вещь как логгирование.

Пользовательские исключения

В Python есть ключевое слово raise. Нужно оно для того чтоб самостоятельно вызывать исключения:

raise Exception("Моя ошибка")
# Вывод:

Traceback (most recent call last):

File "C:/Users/ivand/PycharmProjects/pythonProject/main.py", line 1, in <module>

raise Exception("Моя ошибка")

Exception: Моя ошибка


  

Такие ошибки тоже можно ловить в try и обрабатывать в except:

x_var = float(input('Введите числоn'))
try:
if x_var > 10:
raise Exception()
except:
print('Что-то пошло не так. Возможно, число слишком большое')
# Вывод:

Введите число

11

Что-то пошло не так. Возможно, число слишком большое


  

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

class MyException(Exception):
def __str__(self):
return 'Число слишком большое'

x_var = float(input('Введите числоn'))
try:
if x_var > 10:
raise MyException()
except MyException:
print(MyException())
# Вывод:

Введите число

11

Число слишком большое


  

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

class MyException(Exception):
def __init__(self):
self.message = 'Число слишком большое'
super().__init__(self.message)

x_var = float(input('Введите числоn'))
try:
if x_var > 10:
raise MyException()
except MyException:
print(MyException())
# Вывод:

Введите число

11

Число слишком большое


  

Раз мы объявили метод __init__, следует сказать, что в него можно передавать аргументы:

class MyException(Exception):
def __init__(self, x):
self.x = x
self.message = 'Число {} слишком большое'.format(self.x)
super().__init__(self.message)

x_var = float(input('Введите числоn'))
if x_var > 10:
raise MyException(x_var)
# Вывод:

Введите число

11

Traceback (most recent call last):

File "C:/Users/ivand/PycharmProjects/pythonProject/main.py", line 9, in <module>

raise MyException(x_var)

__main__.MyException: Число 11.0 слишком большое


  

Запись в лог

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

import logging

logging.basicConfig(level=logging.DEBUG)
logging.debug(" Сообщения про отладку")
logging.info(" Информационные сообщения")
logging.warning(" Предупреждения")
logging.error(" Сообщения с ошибками")
logging.critical(" Ну очень важные сообщения")
# Вывод:

DEBUG:root: Сообщения про отладку

INFO:root: Информационные сообщения

WARNING:root: Предупреждения

ERROR:root: Сообщения с ошибками

CRITICAL:root: Ну очень важные сообщения


  

Параметр level= указывает, сообщения какого уровня заносить в лог. К примеру, если указать ‘level= logging.ERROR’, то логгироваться будут только сообщения уровня error и critical. Объединим логгирование и обработку исключений:

import logging

logging.basicConfig(filename="log.txt", level=logging.WARNING)
try:
print(10 / 0)
except Exception:
logging.error(str(Exception))

Содержимое файла log.txt:

ERROR:root:<class 'Exception'>


  

Иерархия исключений

В Python есть иерархия исключений. Это происходит из-за того, что их классы наследуются друг от друга. Вот полный список:

BaseException — базовое исключение, от которого берут начало все остальные

+SystemExit  — исключение, порождаемое функцией sys.exit при выходе из программы

+KeyboardInterrupt  — порождается при прерывании программы пользователем (обычно сочетанием клавиш Ctrl+C)

+GeneratorExit  — порождается при вызове метода close объекта generator

+Exception – исключения

++StopIteration — порождается встроенной функцией next, если в итераторе больше нет элементов

++StopAsyncIteration — используется для остановки асинхронного прохода

++ArithmeticError — арифметическая ошибка

+++FloatingPointError

+++OverflowError

+++ZeroDivisionError

++AssertionError— выражение в функции assert ложно

++AttributeError — объект не имеет данного атрибута (значения или метода)

++BufferError— операция, связанная с буфером, не может быть выполнена

++EOFError— функция наткнулась на конец файла и не смогла прочитать то, что хотела

++ImportError — не удалось импортирование модуля или его атрибута

+++ModuleNotFoundError

++LookupError— некорректный индекс или ключ

+++IndexError

+++KeyError

++MemoryError— недостаточно памяти

++NameError — не найдено переменной с таким именем

+++UnboundLocalError

++OSError — ошибка, связанная с системой

+++BlockingIOError

+++ChildProcessError

+++ConnectionError

++++BrokenPipeError

++++ConnectionAbortedError

++++ConnectionRefusedError

++++ConnectionResetError

+++FileExistsError

+++FileNotFoundError

+++InterruptedError

+++IsADirectoryError

+++NotADirectoryError

+++PermissionError

+++ProcessLookupError

+++TimeoutError

++ReferenceError — попытка доступа к атрибуту со слабой ссылкой

++RuntimeError — возникает, когда исключение не попадает ни под одну из других категорий

+++NotImplementedError

+++RecursionError

++SyntaxError — синтаксическая ошибка

++IndentationError

++TabError

++SystemError — внутренняя ошибка

++TypeError — операция применена к объекту несоответствующего типа

++ValueError — функция получает аргумент правильного типа, но некорректного значения

+++UnicodeError

++++UnicodeDecodeError

++++UnicodeEncodeError

++++UnicodeTranslateError

++Warning — предупреждение

+++DeprecationWarning

+++PendingDeprecationWarning

+++RuntimeWarning

+++SyntaxWarning

+++UserWarning

+++FutureWarning

+++ImportWarning

+++UnicodeWarning

+++BytesWarning

+++ResourceWarning

TL;DR

input function in Python 2.7, evaluates whatever your enter, as a Python expression. If you simply want to read strings, then use raw_input function in Python 2.7, which will not evaluate the read strings.

If you are using Python 3.x, raw_input has been renamed to input. Quoting the Python 3.0 release notes,

raw_input() was renamed to input(). That is, the new input() function reads a line from sys.stdin and returns it with the trailing newline stripped. It raises EOFError if the input is terminated prematurely. To get the old behavior of input(), use eval(input())

In Python 2.7, there are two functions which can be used to accept user inputs. One is input and the other one is raw_input. You can think of the relation between them as follows

input = eval(raw_input)

Consider the following piece of code to understand this better

>>> dude = "thefourtheye"
>>> input_variable = input("Enter your name: ")
Enter your name: dude
>>> input_variable
'thefourtheye'

input accepts a string from the user and evaluates the string in the current Python context. When I type dude as input, it finds that dude is bound to the value thefourtheye and so the result of evaluation becomes thefourtheye and that gets assigned to input_variable.

If I enter something else which is not there in the current python context, it will fail will the NameError.

>>> input("Enter your name: ")
Enter your name: dummy
Traceback (most recent call last):
  File "<input>", line 1, in <module>
  File "<string>", line 1, in <module>
NameError: name 'dummy' is not defined

Security considerations with Python 2.7’s input:

Since whatever user types is evaluated, it imposes security issues as well. For example, if you have already loaded os module in your program with import os, and then the user types in

os.remove("/etc/hosts")

this will be evaluated as a function call expression by python and it will be executed. If you are executing Python with elevated privileges, /etc/hosts file will be deleted. See, how dangerous it could be?

To demonstrate this, let’s try to execute input function again.

>>> dude = "thefourtheye"
>>> input("Enter your name: ")
Enter your name: input("Enter your name again: ")
Enter your name again: dude

Now, when input("Enter your name: ") is executed, it waits for the user input and the user input is a valid Python function invocation and so that is also invoked. That is why we are seeing Enter your name again: prompt again.

So, you are better off with raw_input function, like this

input_variable = raw_input("Enter your name: ")

If you need to convert the result to some other type, then you can use appropriate functions to convert the string returned by raw_input. For example, to read inputs as integers, use the int function, like shown in this answer.

In python 3.x, there is only one function to get user inputs and that is called input, which is equivalent to Python 2.7’s raw_input.