Ошибка типа typeerror python

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

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

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

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

Ошибки могут быть разных видов:

• Синтаксические
• Недостаточно памяти
• Ошибки рекурсии
• Исключения

Разберем их по очереди.

Синтаксические ошибки (SyntaxError)

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

Рассмотрим на примере.

a = 8
b = 10
c = a b

File "", line 3
 c = a b
       ^
SyntaxError: invalid syntax

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

Недостаточно памяти (OutofMemoryError)

Ошибки памяти чаще всего связаны с оперативной памятью компьютера и относятся к структуре данных под названием “Куча” (heap). Если есть крупные объекты (или) ссылки на подобные, то с большой долей вероятности возникнет ошибка OutofMemory. Она может появиться по нескольким причинам:

• Использование 32-битной архитектуры Python (максимальный объем выделенной памяти невысокий, между 2 и 4 ГБ);
• Загрузка файла большого размера;
• Запуск модели машинного обучения/глубокого обучения и много другое;

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

Но поскольку Python использует архитектуру управления памятью из языка C (функция malloc()), не факт, что все процессы восстановятся — в некоторых случаях MemoryError приведет к остановке. Следовательно, обрабатывать такие ошибки не рекомендуется, и это не считается хорошей практикой.

Ошибка рекурсии (RecursionError)

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

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

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

def recursion():
    return recursion()

recursion()

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

RecursionError                            Traceback (most recent call last)

 in 
----> 1 recursion()


 in recursion()
      1 def recursion():
----> 2     return recursion()


... last 1 frames repeated, from the frame below ...


 in recursion()
      1 def recursion():
----> 2     return recursion()


RecursionError: maximum recursion depth exceeded

Ошибка отступа (IndentationError)

Эта ошибка похожа по духу на синтаксическую и является ее подвидом. Тем не менее она возникает только в случае проблем с отступами.

Пример:

for i in range(10):
    print('Привет Мир!')

  File "", line 2
    print('Привет Мир!')
        ^
IndentationError: expected an indented block

Исключения

Даже если синтаксис в инструкции или само выражение верны, они все равно могут вызывать ошибки при исполнении. Исключения Python — это ошибки, обнаруживаемые при исполнении, но не являющиеся критическими. Скоро вы узнаете, как справляться с ними в программах Python. Объект исключения создается при вызове исключения Python. Если скрипт не обрабатывает исключение явно, программа будет остановлена принудительно.

Программы обычно не обрабатывают исключения, что приводит к подобным сообщениям об ошибке:

Ошибка типа (TypeError)

a = 2
b = 'PythonRu'
a + b

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

TypeError                                 Traceback (most recent call last)

 in 
      1 a = 2
      2 b = 'PythonRu'
----> 3 a + b


TypeError: unsupported operand type(s) for +: 'int' and 'str'

Ошибка деления на ноль (ZeroDivisionError)

10 / 0

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

ZeroDivisionError                         Traceback (most recent call last)

 in 
----> 1 10 / 0


ZeroDivisionError: division by zero

Есть разные типы исключений в Python и их тип выводится в сообщении: вверху примеры TypeError и ZeroDivisionError. Обе строки в сообщениях об ошибке представляют собой имена встроенных исключений Python.

Оставшаяся часть строки с ошибкой предлагает подробности о причине ошибки на основе ее типа.

Теперь рассмотрим встроенные исключения Python.

Встроенные исключения

BaseException
 +-- SystemExit
 +-- KeyboardInterrupt
 +-- GeneratorExit
 +-- Exception
      +-- StopIteration
      +-- StopAsyncIteration
      +-- ArithmeticError
      |    +-- FloatingPointError
      |    +-- OverflowError
      |    +-- ZeroDivisionError
      +-- AssertionError
      +-- 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

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

• Try: он запускает блок кода, в котором ожидается ошибка.
• Except: здесь определяется тип исключения, который ожидается в блоке try (встроенный или созданный).
• Else: если исключений нет, тогда исполняется этот блок (его можно воспринимать как средство для запуска кода в том случае, если ожидается, что часть кода приведет к исключению).
• Finally: вне зависимости от того, будет ли исключение или нет, этот блок кода исполняется всегда.

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

Ошибка прерывания с клавиатуры (KeyboardInterrupt)

Исключение KeyboardInterrupt вызывается при попытке остановить программу с помощью сочетания Ctrl + C или Ctrl + Z в командной строке или ядре в Jupyter Notebook. Иногда это происходит неумышленно и подобная обработка поможет избежать подобных ситуаций.

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

try:
    inp = input()
    print('Нажмите Ctrl+C и прервите Kernel:')
except KeyboardInterrupt:
    print('Исключение KeyboardInterrupt')
else:
    print('Исключений не произошло')

Исключение KeyboardInterrupt

Стандартные ошибки (StandardError)

Рассмотрим некоторые базовые ошибки в программировании.

Арифметические ошибки (ArithmeticError)

• Ошибка деления на ноль (Zero Division);
• Ошибка переполнения (OverFlow);
• Ошибка плавающей точки (Floating Point);

Все перечисленные выше исключения относятся к классу Arithmetic и вызываются при ошибках в арифметических операциях.

Деление на ноль (ZeroDivisionError)

Когда делитель (второй аргумент операции деления) или знаменатель равны нулю, тогда результатом будет ошибка деления на ноль.

try:  
    a = 100 / 0
    print(a)
except ZeroDivisionError:  
    print("Исключение ZeroDivisionError." )
else:  
    print("Успех, нет ошибок!")

Исключение ZeroDivisionError.

Переполнение (OverflowError)

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

try:  
    import math
    print(math.exp(1000))
except OverflowError:  
    print("Исключение OverFlow.")
else:  
    print("Успех, нет ошибок!")

Исключение OverFlow.

Ошибка утверждения (AssertionError)

Когда инструкция утверждения не верна, вызывается ошибка утверждения.

Рассмотрим пример. Предположим, есть две переменные: a и b. Их нужно сравнить. Чтобы проверить, равны ли они, необходимо использовать ключевое слово assert, что приведет к вызову исключения Assertion в том случае, если выражение будет ложным.

try:  
    a = 100
    b = "PythonRu"
    assert a == b
except AssertionError:  
    print("Исключение AssertionError.")
else:  
    print("Успех, нет ошибок!")

Исключение AssertionError.

Ошибка атрибута (AttributeError)

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

class Attributes(obj):
    a = 2
    print(a)

try:
    obj = Attributes()
    print(obj.attribute)
except AttributeError:
    print("Исключение AttributeError.")

2
Исключение AttributeError.

Ошибка импорта (ModuleNotFoundError)

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

import nibabel

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

ModuleNotFoundError                       Traceback (most recent call last)

 in 
----> 1 import nibabel


ModuleNotFoundError: No module named 'nibabel'

Ошибка поиска (LookupError)

LockupError выступает базовым классом для исключений, которые происходят, когда key или index используются для связывания или последовательность списка/словаря неверна или не существует.

Здесь есть два вида исключений:

• Ошибка индекса (IndexError);
• Ошибка ключа (KeyError);

Ошибка ключа

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

try:  
    a = {1:'a', 2:'b', 3:'c'}  
    print(a[4])  
except LookupError:  
    print("Исключение KeyError.")
else:  
    print("Успех, нет ошибок!")

Исключение KeyError.

Ошибка индекса

Если пытаться получить доступ к индексу (последовательности) списка, которого не существует в этом списке или находится вне его диапазона, будет вызвана ошибка индекса (IndexError: list index out of range python).

try:
    a = ['a', 'b', 'c']  
    print(a[4])  
except LookupError:  
    print("Исключение IndexError, индекс списка вне диапазона.")
else:  
    print("Успех, нет ошибок!")

Исключение IndexError, индекс списка вне диапазона.

Ошибка памяти (MemoryError)

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

Ошибка имени (NameError)

Ошибка имени возникает, когда локальное или глобальное имя не находится.

В следующем примере переменная ans не определена. Результатом будет ошибка NameError.

try:
    print(ans)
except NameError:  
    print("NameError: переменная 'ans' не определена")
else:  
    print("Успех, нет ошибок!")

NameError: переменная 'ans' не определена

Ошибка выполнения (Runtime Error)

Ошибка «NotImplementedError»
Ошибка выполнения служит базовым классом для ошибки NotImplemented. Абстрактные методы определенного пользователем класса вызывают это исключение, когда производные методы перезаписывают оригинальный.

class BaseClass(object):
    """Опередляем класс"""
    def __init__(self):
        super(BaseClass, self).__init__()
    def do_something(self):
	# функция ничего не делает
        raise NotImplementedError(self.__class__.__name__ + '.do_something')

class SubClass(BaseClass):
    """Реализует функцию"""
    def do_something(self):
        # действительно что-то делает
        print(self.__class__.__name__ + ' что-то делает!')

SubClass().do_something()
BaseClass().do_something()

SubClass что-то делает!



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

NotImplementedError                       Traceback (most recent call last)

 in 
     14
     15 SubClass().do_something()
---> 16 BaseClass().do_something()


 in do_something(self)
      5     def do_something(self):
      6         # функция ничего не делает
----> 7         raise NotImplementedError(self.__class__.__name__ + '.do_something')
      8
      9 class SubClass(BaseClass):


NotImplementedError: BaseClass.do_something

Ошибка типа (TypeError)

Ошибка типа вызывается при попытке объединить два несовместимых операнда или объекта.

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

try:
    a = 5
    b = "PythonRu"
    c = a + b
except TypeError:
    print('Исключение TypeError')
else:
    print('Успех, нет ошибок!')

Исключение TypeError

Ошибка значения (ValueError)

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

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

try:
    print(float('PythonRu'))
except ValueError:
    print('ValueError: не удалось преобразовать строку в float: 'PythonRu'')
else:
    print('Успех, нет ошибок!')

ValueError: не удалось преобразовать строку в float: 'PythonRu'

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

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

Это можно сделать, создав новый класс, который будет наследовать из класса Exception в Python.

class UnAcceptedValueError(Exception):   
    def __init__(self, data):    
        self.data = data
    def __str__(self):
        return repr(self.data)

Total_Marks = int(input("Введите общее количество баллов: "))
try:
    Num_of_Sections = int(input("Введите количество разделов: "))
    if(Num_of_Sections < 1):
        raise UnAcceptedValueError("Количество секций не может быть меньше 1")
except UnAcceptedValueError as e:
    print("Полученная ошибка:", e.data)

Введите общее количество баллов: 10
Введите количество разделов: 0
Полученная ошибка: Количество секций не может быть меньше 1

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

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

У использования исключений есть свои побочные эффекты, как, например, то, что программы с блоками try-except работают медленнее, а количество кода возрастает.

Дальше пример, где модуль Python timeit используется для проверки времени исполнения 2 разных инструкций. В stmt1 для обработки ZeroDivisionError используется try-except, а в stmt2 — if. Затем они выполняются 10000 раз с переменной a=0. Суть в том, чтобы показать разницу во времени исполнения инструкций. Так, stmt1 с обработкой исключений занимает больше времени чем stmt2, который просто проверяет значение и не делает ничего, если условие не выполнено.

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

import timeit
setup="a=0"
stmt1 = '''
try:
    b=10/a
except ZeroDivisionError:
    pass'''

stmt2 = '''
if a!=0:
    b=10/a'''

print("time=",timeit.timeit(stmt1,setup,number=10000))
print("time=",timeit.timeit(stmt2,setup,number=10000))

time= 0.003897680000136461
time= 0.0002797570000439009

Выводы!

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

Обработка исключений — один из основных факторов, который делает код готовым к развертыванию. Это простая концепция, построенная всего на 4 блоках: try выискивает исключения, а except их обрабатывает.

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

TypeError is one among the several standard Python exceptions. TypeError is raised whenever an operation is performed on an incorrect/unsupported object type. For example, using the + (addition) operator on a string and an integer value will raise TypeError.

Examples

The general causes for TypeError being raised are:

1. Unsupported operation between two types:

In the following example, the variable ‘geek’ is a string and the variable ‘num’ is an integer. The + (addition) operator cannot be used between these two types and hence TypeError is raised.

Output :

TypeError: must be str, not int

2. Calling a non-callable identifier:

In the below example code, the variable ‘geek’ is a string and is non-callable in this context. Since it is called in the print statement, TypeError is raised.

Output :

TypeError: 'str' object is not callable

3. Incorrect type of list index:

In Python, list indices must always be an integer value. Since the index value used in the following code is a string, it raises TypeError.

Output :

TypeError: list indices must be integers or slices, not str

4. Iterating through a non-iterative identifier:

In the following code, the value 1234.567890 is a floating-point number and hence it is non-iterative. Forcing Python to iterate on a non-iterative identifier will raise TypeError.

Output :

TypeError: 'float' object is not iterable

Handling TypeError

TypeErrors are raised mostly in situations where the programmer fails to check the type of object before performing an operation on them. They can be handled specifically by mentioning them in the except block. In the following example, when one of the indices is found to be an incorrect type, an exception is raised and handled by the program.

Output :

Geeky
GeeksforGeeks
TypeError: Check list of indices
Geek

Last Updated :
20 Aug, 2020

Like Article

Save Article

() translation by (you can also view the original English article)

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

Исключения отличаются от синтаксических ошибок. Они возникают во время выполнения программы, когда происходит что-то неожиданное. Например, допустим, вы просите пользователя ввести число для выполнения деления.  Теперь, если пользователь вводит строку вместо числа, а вы пытаетесь разделить число на указанные данные, программа выведет TypeError.

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

1

keep_asking = True

2

3

while keep_asking:

4

    x = int(input("Enter a number: "))

5

    print("Dividing 50 by", x,"will give you :", 50/x)

Пока вы вводите значение в виде целого числа, программа будет работать правильно. Однако, как только вы введёте строку или даже десятичное число, вы получите исключение ValueError.

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

Некоторые общие исключения

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

• NameError: это исключение возникает, когда программа не может найти локальное или глобальное имя. Имя, которое не удалось найти, включено в сообщение об ошибке.
• TypeError: это исключение возникает, когда функция передается объекту несоответствующего типа в качестве аргумента. Более подробная информация о неправильном типе содержится в сообщении об ошибке.
• ValueError: это исключение возникает, когда аргумент функции имеет правильный тип, но недопустимое значение.
• NotImplementedError: это исключение возникает, когда объект должен поддерживать операцию, но он ещё не реализован. Вы не должны использовать эту ошибку, если данная функция не предназначена для поддержки типа входящего аргумента. В таких ситуациях более целесообразно подбрасывать исключение TypeError.
• ZeroDivisionError: это исключение возникает, когда вы предоставляете второй аргумент для операции деления по модулю равный ноль.
• FileNotFoundError: это исключение возникает, когда файл или каталог, запрошенные программой, не существуют.

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

Обработка исключения

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

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

1

keep_asking = True

2

3

while keep_asking:

4

    try:

5

        x = int(input("Please enter a number: "))

6

        print("Dividing 50 by", x,"will give you :", 50/x)

7

    except ValueError:

8

        print("The input was not an integer. Please try again...")

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

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

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

Вы также можете обрабатывать несколько исключений с помощью отдельного блока except, передавая эти исключения как tuple.

1

except (ZeroDivisionError, ValueError, TypeError):

2

    print("Something has gone wrong..")

3

    # code to deal with the exception

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

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

1

import math

2

import sys

3

4

try:

5

    result = math.factorial(2.4)

6

except:

7

    print("Something Unexpected has happened.",sys.exc_info()[0])

8

else:

9

    print("The factorial is", result)

Использование else

Вы также можете использовать else в конструкции try... except. Блок else должен содержать код, который будет выполнен, если try не вызвало каких-либо исключений. Это может быть полезно для того, чтобы убедиться, что вы не добавили код в блок try, исключения которого вы не собираетесь отлавливать. Следует упомянуть одно: если вы решите использовать else, вы должны включить его после всех except, но до блока finally.

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

1

keep_asking = True

2

3

while keep_asking:

4

    try:

5

        x = int(input("Please enter a number: "))

6

    except ValueError:

7

        print("The input was not a valid integer. Please try again...")

8

    else:

9

        print("Dividing 50 by", x,"will give you :", 50/x)

Очистка с помощью finally

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

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

1

keep_asking = True

2

3

while keep_asking:

4

    try:

5

        x = int(input("Please enter a number: "))

6

    except ValueError:

7

        print("The input was not a valid integer. Please try again...")

8

    else:

9

        print("Dividing 50 by", x,"will give you :", 50/x)

10

    finally:

11

        print("Already did everything necessary.")

Если какое-либо из описанных вами except не обрабатывает вызванное исключение, то такое же исключение снова возникнет после выполнения кода в блоке finally.

Более сложный пример

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

Следующий код проверяет два исключения: TypeError и ValueError. Блок else используется для вывода факториала. Вы можете видеть на выходе, что этот код выполняется только тогда, когда исключение не выбрасывается.

1

import math

2

3

number_list = [10,-5,1.2,'apple']

4

5

for number in number_list:

6

    try:

7

        number_factorial = math.factorial(number)

8

    except TypeError:

9

        print("Factorial is not supported for given input type.")

10

    except ValueError:

11

        print("Factorial only accepts positive integer values.", number," is not a positive integer.")

12

    else:

13

        print("The factorial of",number,"is", number_factorial)

14

    finally:

15

        print("Release any resources in use.")

Вышеприведенный код выводит следующий результат:

1

The factorial of 10 is 3628800

2

Releasing any resources in use.

3

4

Factorial only accepts positive integer values. -5  is not a positive integer.

5

Releasing any resources in use.

6

7

Factorial only accepts positive integer values. 1.2  is not a positive integer.

8

Releasing any resources in use.

9

10

Factorial is not supported for given input type.

11

Releasing any resources in use.

Ещё одна вещь, заслуживающая внимания, заключается в том, что код внутри finally выполняется для каждого элемента в списке.

Заключительные мысли

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

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