Ошибка типизации может привести к остановке работы программа на python - Ремонт и установка крупной бытовой техники

Рассказывает команда SimbirSoft

Первые упоминания о подсказках типов в языке программирования Python появились в базе Python Enhancement Proposals (PEP-483). Такие подсказки нужны для улучшения статического анализа кода и автодополнения редакторами, что помогает снизить риски появления багов в коде.

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

Для обозначения базовых типов переменных используются сами типы:

str
int
float
bool
complex
bytes
etc.

Пример использования базовых типов в python-функции:

def func(a: int, b: float) -> str:  
    a: str = f"{a}, {b}"  
    return a

Помимо этого, можно параметризировать более сложные типы, например, List. Такие типы могут принимать значения параметров, которые помогают более точно описать тип функции. Так, например, List[int] указывает на то, что список состоит только из целочисленных значений.

Пример кода:

from typing import List  
  
def func(n: int) -> List[int]:  
    return list(range(n))

Кроме List, существуют и другие типы из модуля typing, которые можно параметризировать. Такие типы называются Generic-типами. Такого рода типа определены для многих встроенных в Python структур данных:

Set[x]
FrozenSet[x]
ByteString[x]
Dict[x, y]
DefaultDict[x, y]
OrderedDict[x, y]
ChainMap[x,y]
Counter[x, int]
Deque[x]
и т.д.

Как можно заметить, некоторые типы имеют несколько параметров, которые можно описать. Например, Dict[x, y] означает, что это будет словарь, где ключи будут иметь тип x, а значения – тип y.

Также есть более абстрактные типы, например:

Mapping[x, y] – объект имеет реализации метода __getitem__;
Iterable[x] – объект имеет реализацию метода __iter__.

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

from typing import Callable  

def func(f: Callable[[int, int], bool]) -> bool:  
    return f(1,2)  
                                                                                
func(lambda x, y: x == y)                                                      
>>> False

Тип Callable:

говорит о том, что у объекта реализован метод __call__;
описывает типы параметров к этому методу.

На первом месте стоит массив типов входных параметров, на втором — тип возвращаемого значения.

Про остальные абстрактные типы контейнеров можно прочитать в документации Python.

Также есть более конкретные типы, например Literal[x], где x указывает не тип, а конкретное значение. Например Literal[3] означает цифру 3. Используют такой тип крайне редко.

Также Python позволяет определять свои Generic-типы.

from typing import TypeVar, Generic  
     
T = TypeVar('T')  
   
class Stack(Generic[T]):  
    def __init__(self) -> None:  
        # Create an empty list with items of type T  
        self.items: List[T] = []  
   
    def push(self, item: T) -> None:  
        self.items.append(item)  
 
    def pop(self) -> T:  
        return self.items.pop()  

    def empty(self) -> bool:  
        return not self.items

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

def func(stack: Stack[int]) -> None:  
     stack.push(11)  
     stack.push(-2)  
                                                                                  
s = Stack[int]()                                                               
func(s)                                                                        
s.empty()                                                                      
>>> False

s.items                                                                        
>>> [11, -2]

Для определения собственных типов наследование возможно не только от Generic, но и от других абстрактных типов, например, таких, как Mapping, Iterable.

from typing import Generic, TypeVar, Mapping, Iterator, Dict  
   
KeyType = TypeVar('KeyType')  
ValueType = TypeVar('ValueType')  

class MyMap(Mapping[KeyType, ValueType]):  # This is a generic subclass of Mapping  
    def __getitem__(self, k: KeyType) -> ValueType:  
        ...  # Implementations omitted  
    def __iter__(self) -> Iterator[KeyType]:  
        ...  
    def __len__(self) -> int:  
        ...

На месте KeyType или ValueType могут быть конкретные типы.

Также есть специальные конструкции, которые позволяют комбинировать типы. Например, Union[x, y, ...] — один из типов. Если переменной может быть как int, так и float, то как тип следует указать Union[int, float]. Если переменной может быть как int, так и None, то в качестве типа можно указать Union[int,None] или, что предпочтительно, Optional[int].

Зачем это нужно

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

Допустим, у вас есть класс юзера и функция, которая преобразует json в User.

from typing import Dict, Union, Optional                                        

from dataclasses import dataclass                                               

@dataclass  
class User:  
    name: str  
    surname: str  
    age: int                                                                        

def get_user_from_json(json_dict: Dict[str, Optional[Union[int, str]]]) -> User:  
    name = json_dict.get("name")  
    surname = json_dict.get("surname")  
    age = json_dict.get("age")  
    if (age is None or  
        name is None or  
        surname is None):  
        raise ValueError("Not enough information")  
    return User(age=age, name=name, surname=surname)

Конечно, можно написать и проще:

def get_user_from_json(json_dict: Dict[str, Optional[Union[int, str]]]) -> User:  
    return User(age=json_dict["age"], name=json_dict["name"], surname=json_dict["surname"])

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

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

from pydantic import BaseModel                                                 

class User(BaseModel):  
    name: str  
    surname: str  
    age: int  
                                                                              

def get_user_from_json(json_dict: Dict[str, Optional[Union[int, str]]]) -> User:  
    return User(**json_dict)                                                                               

get_user_from_json({  
    "name": "ssa",  
    "surname": "ddd",  
    "age": 10  
})                                                                             
>>> User(name='ssa', surname='ddd', age=10)

get_user_from_json({  
    "name": "ssa",  
    "surname": "ddd",  
    "age": "10"  
 })                                                                             
>>> User(name='ssa', surname='ddd', age=10)

get_user_from_json({  
    "name": "ssa",  
    "surname": "ddd",  
    "age": "d"  
})
--------------------------------------
ValidationError: 1 validation error for User
age
 value is not a valid integer (type=type_error.integer)

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

from pydantic import BaseModel, validator                                                   

class User(BaseModel):  
    name: str  
    age: int  

    @validator('age')  
    def validate_age(cls, value):  
        if int(value) < 10:  
            raise ValueError("too low")  
        return str(value)  
                                                                                       
User(name='Brian', age=33)                                                                  
>>> User(name='Brian', age='33')

В данном примере созданный User после валидации будет иметь отличный от того, который был указан в модели. Это ведет к возможным крупным багам, которые лучше всегда избегать.

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

from fastapi import FastAPI  
from typing import Optional  
from pydantic import BaseModel  
   
app = FastAPI()  

class Item(BaseModel):  
    name: str  
    price: float  
    is_offer: Optional[bool] = None  

@app.put("/item")  
async def put_item(item: Item):  
    return {"item_name": item.name, "item_price": item.price}

В данном примере эндпоинт /item автоматически валидирует входящий json и передает его в функцию как требуемую модель.

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

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

Нововведения Python 3.9.0

Начиная с недавно вышедшей версии Python 3.9, у разработчиков больше нет необходимости импортировать абстрактные коллекции для описания типов. Теперь вместо typing.Dict[x, y] можно использовать dict[x,y], то же самое происходит с Deque, List, Counter и т.д. Полное описание этого нововведения можно прочитать тут: PEP-585.

Также добавили аннотации типов, которые в дальнейшем могут быть использованы инструментами статического анализа. variable: Annotated[T, x] где T — тип переменной variable, а x — некоторые метаданные для переменной. По оценкам некоторых авторов, эти метаданные могут быть использованы также и во время выполнения (подробности смотрите в PEP-593).

Заключение

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

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

Программа не работает. Что делать?

Моя программа не работает! Что делать? В данной статье я постараюсь собрать наиболее частые ошибки начинающих программировать на python 3, а также расскажу, как их исправлять.

Проблема: Моя программа не запускается. На доли секунды появляется чёрное окошко, а затем исчезает.

Причина: после окончания выполнения программы (после выполнения всего кода или при возникновении исключения программа закрывается. И если вы её вызвали двойным кликом по иконке (а вы, скорее всего, вызвали её именно так), то она закроется вместе с окошком, в котором находится вывод программы.

Решение: запускать программу через IDLE или через консоль.

Проблема: Не работает функция input. Пишет SyntaxError.

Пример кода:

Причина: Вы запустили Python 2.

Проблема: Где-то увидел простую программу, а она не работает.

Пример кода:

Причина: Вам подсунули программу на Python 2.

Решение: Прочитать об отличиях Python 2 от Python 3. Переписать её на Python 3. Например, данная программа на Python 3 будет выглядеть так:

Проблема: TypeError: Can’t convert ‘int’ object to str implicitly.

Пример кода:

Причина: Нельзя складывать строку с числом.

Решение: Привести строку к числу с помощью функции int(). Кстати, заметьте, что функция input() всегда возвращает строку!

Проблема: SyntaxError: invalid syntax.

Пример кода:

Причина: Забыто двоеточие.

Проблема: SyntaxError: invalid syntax.

Пример кода:

Причина: Забыто равно.

Проблема: NameError: name ‘a’ is not defined.

Пример кода:

Причина: Переменная «a» не существует. Возможно, вы опечатались в названии или забыли инициализировать её.

Решение: Исправить опечатку.

Проблема: IndentationError: expected an indented block.

Пример кода:

Причина: Нужен отступ.

Проблема: TabError: inconsistent use of tabs and spaces in indentation.

Пример кода:

Причина: Смешение пробелов и табуляции в отступах.

Решение: Исправить отступы.

Проблема: UnboundLocalError: local variable ‘a’ referenced before assignment.

Пример кода:

Причина: Попытка обратиться к локальной переменной, которая ещё не создана.

Проблема: Программа выполнилась, но в файл ничего не записалось / записалось не всё.

Пример кода:

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

Проблема: Здесь может быть ваша проблема. Комментарии чуть ниже 🙂

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

Python добавлен в PATH, и прекрасно работает в CMD.

Python установил на официальном сайте, обновил Visual studio, удалил Avast, частично ограничил антивирус Window — ничего не изменилось.

OC — Windows 10 64Bit

Немного дополню варианты ответа.
Запуск скриптов через IDE это для всех свои нюансы. Чтобы проверить работу скрипта запустите его через консоль cmd . Там будут видны все ошибки если они есть. Скрипт закрывается мгновенно по двум причинам:

Значения исключений и ошибок в Python

Синтаксис обработки исключений

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Исключения

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Ошибка ключа

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Выводы!

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

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

Типизация в Python

Очень часто языки программирования сравнивают по их типизации. Иначе говоря — по тому, как устроена их система типов. Давайте разберемся, какая типизация у Python, и что это означает.

Типизация в Python

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

Неявная типизация

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

a = 1  # int
b = 1.1  # float
c = 'a'  # str

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

def func(a: int, b: str) -> float:
    return round(float(a / len(b)), 2)


var: float = func(3, [1, 1, 1])  # 1.0

# Expected type 'str', got 'list[int]' instead

Это называется аннотацией типов. Ее возможности сильно расширяет модуль typing, активно развивающийся с версии Python 3.5. Аннотации никак не влияют на выполнение программы, но IDE может считывать их и предупреждать, если вы использовали не тот тип.

Сильная типизация

Python — язык с сильной типизацией. Это означает, что различные типы нельзя смешивать в одних выражениях.

2 + '2'
# Traceback (most recent call last):
#   File "C:main.py", line 1, in <module>
#     2 + '2'
#     ~~^~~~~
# TypeError: unsupported operand type(s) for +: 'int' and 'str'

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

Типы int и float могут свободно взаимодействовать. Это продиктовано удобством и естественностью таких преобразований.

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

Динамическая типизация

Python — язык с динамической типизацией. Это означает, что с определенным типом связывается не переменная, а ее значение. Если бы Python был языком со статической типизацией, мы бы не смогли сделать так:

a = 1
a = 'a'
a = SomeClass()

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

a = (1, 1, 1, 3, 1, 1)
a = list(set(a))
# [1, 3]

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

def second(a):
    try:
        return a[1]
    except TypeError:
        return None

second([1, 2])  # 2
second('abcd')  # b
second(1)  # None

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

Утиная типизация

«If it looks like a duck, swims like a duck, and quacks like a duck, then it probably is a duck.»

В Python применяется утиная типизация. Это означает, что тип данных не имеет значения — важно лишь то, какие методы и свойства они поддерживают. Например, чтобы узнать, длину объекта, мы можем использовать функцию len(). Она не проверяет, к какому типу относится объект, а всего лишь обращается к магическому методу __len__(). Можно узнать длину любого объекта, у которого он прописан (не важно, как именно). И наоборот, объект с очевидной длиной, но без метода __len__() нельзя обработать этой функцией.

class SomeClass:
    length = 12

    def __len__(self):
        return self.length


len('123')
# 3
len([1, 2])
# 2
len(SomeClass())
# 12
len(123)
# Traceback (most recent call last):
#   File "C:main.py", line 13, in <module>
#     len(123)
# TypeError: object of type 'int' has no len()

Заключение

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

Подпишитесь на новости по email

Проверка типов – это функция языка программирования, которая определяет, как создаются переменные и их типы определяются компилятором или интерпретатором языка.

Содержание

Какие существуют виды проверки типов?
1) Что такое проверка статического типа?
2) Что такое проверка динамического типа?
3) Статически типизированные языки против динамически типизированных языков
Утиный ввод в Python
Преимущества подсказок типа
Недостатки подсказок типа
Атрибут __annotations__
Проверка типа среды выполнения
Проверка статического типа
Заключение

Какие существуют виды проверки типов?

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

Статически типизированные языки – C, Java, C ++ и т.д.
Языки с динамической типизацией – JavaScript, Python, Ruby и т.д.

1) Что такое проверка статического типа?

Тип переменной известен во время компиляции. Тип переменной фиксирован, и мы не можем изменить его позже.

Давайте посмотрим на объявление переменной в Java.

String str = "Hello";

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

str = 10; // Type mismatch: cannot convert from int to String 

int str = 10; // Duplicate local variable str

2) Что такое проверка динамического типа?

Тип переменной определяется во время выполнения. Мы не указываем тип переменной в коде. Код ведет себя по-разному в зависимости от типа объекта во время выполнения.

Давайте посмотрим на пример определения функции в Python.

def add(x, y):
    return x + y


print(add(10, 5))
print(add('A', 'B'))

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

Если мы передадим какой-либо другой настраиваемый объект, мы можем получить другой ответ или возникнет ошибка, если оператор «+» ими не поддерживается.

3) Статически типизированные языки против динамически типизированных языков

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

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

Давайте посмотрим на это на примере настраиваемого объекта и функции add(), которую мы определили.

def add(x, y):
    return x + y

class Data:

    def __init__(self, i):
        self.id = i

d1 = Data(10)
d2 = Data(5)

print(add(d1, d2))

Этот код вызовет следующую ошибку времени выполнения:

Traceback (most recent call last):
  File "/Users/pankaj/Documents/PycharmProjects/hello-world/journaldev/type_checking.py", line 12, in <module>
    print(add(d1, d2))
  File "/Users/pankaj/Documents/PycharmProjects/hello-world/journaldev/type_checking.py", line 2, in add
    return x + y
TypeError: unsupported operand type(s) for +: 'Data' and 'Data'

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

def __add__(self, other):
    return self.id + other.id

Теперь оператор печати напечатает 15, и код не вызовет ошибок. Так что, по сути, тип объекта вообще не имеет значения. Пока определены необходимые функции для поддержки операции, проблем из-за типа объекта не возникнет.

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

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

def calculate(x, y, op='sum'):
    if op == 'divide':
        return x // y
    if op == 'difference':
        return x - y
    if op == 'multiply':
        return x * y
    # default is sum
    return x + y

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

print(calculate(10, 3, 'divide'))  # 3
print(calculate(10, 5))  # 15
print(calculate('A', 'B'))  # AB

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

def calculate1(x: int, y: int, op: str = 'sum') -> int:
    # same code as above

Подсказки типа аргумента функции снабжены двоеточием (:), а тип возвращаемого значения – знаком ->.

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

Но сторонние инструменты, такие как средства проверки типов, IDE, линтеры и т.д., могут анализировать это, чтобы предупредить нас о возможности неправильных типов аргументов. Например, если мы передадим строковые аргументы этой функции, PyCharm IDE выдаст предупреждающее сообщение как «Ожидаемый тип int, вместо этого получил str».

Преимущества подсказок типа

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

Недостатки подсказок типа

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

Атрибут annotations

Функции Python имеют атрибут __annotations__, который содержит информацию о подсказках типа.

def calculate(x, y, op='sum'):
    pass

def calculate1(x: int, y: int, op: str = 'sum') -> int:
    pass

print(calculate.__annotations__)  # {}

print(calculate1.__annotations__) 
# {'x': <class 'int'>, 'y': <class 'int'>, 'op': <class 'str'>, 'return': <class 'int'>}

Проверка типа среды выполнения

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

>>> x = 10
>>> type(x)
<class 'int'>
>>> 
>>> s1 = 'Hello'
>>> type(s1)
<class 'str'>
>>>

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

>>> x = 10
>>> isinstance(x, int)
True
>>> isinstance(x, str)
False
>>>
>>> o = object()
>>> isinstance(o, (int, str, object))
True

Проверка статического типа

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

Модуль mypy проверит код и выдаст ошибки, если мы вызываем функцию с несовместимыми аргументами типа данных. Мы можем установить модуль mypy с помощью команды PIP.

pip install mypy

Допустим, у нас есть сценарий Python type_checking.py с приведенным ниже содержимым.

def calculate(x, y, op='sum'):
    pass


def calculate1(x: int, y: int, op: str = 'sum') -> int:
    pass


calculate('a', 'b')
calculate1('a', 'b')

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

$ mypy type_checking.py
type_checking.py:10: error: Argument 1 to "calculate1" has incompatible type "str"; expected "int"
type_checking.py:10: error: Argument 2 to "calculate1" has incompatible type "str"; expected "int"
Found 2 errors in 1 file (checked 1 source file)
$

Заключение

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

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

Исключения в языках программирования

Исключениями (exceptions) в языках программирования называют проблемы, возникающие в ходе выполнения программы, которые допускают возможность дальнейшей ее работы в рамках основного алгоритма. Типичным примером исключения является деление на ноль, невозможность считать данные из файла (устройства), отсутствие доступной памяти, доступ к закрытой области памяти и т.п. Для обработки таких ситуаций в языках программирования, как правило, предусматривается специальный механизм, который называется обработка исключений (exception handling).

Исключения разделяют на синхронные и асинхронные. Синхронные исключения могут возникнуть только в определенных местах программы. Например, если у вас есть код, который открывает файл и считывает из него данные, то исключение типа “ошибка чтения данных” может произойти только в указанном куске кода. Асинхронные исключения могут возникнуть в любой момент работы программы, они, как правило, связаны с какими-либо аппаратными проблемами, либо приходом данных. В качестве примера можно привести сигнал отключения питания.

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

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

В Python выделяют два различных вида ошибок: синтаксические ошибки и исключения.

Синтаксические ошибки в Python

Синтаксические ошибки возникают в случае если программа написана с нарушениями требований Python к синтаксису. Определяются они в процессе парсинга программы. Ниже представлен пример с ошибочным написанием функции print.

>>> for i in range(10):
    prin("hello!")

Traceback (most recent call last):
  File "<pyshell#2>", line 2, in <module>
    prin("hello!")
NameError: name 'prin' is not defined

Исключения в Python

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

Пример исключения ZeroDivisionError, которое возникает при делении на 0.

>>> a = 10
>>> b = 0
>>> c = a / b
Traceback (most recent call last):
  File "<pyshell#5>", line 1, in <module>
    c = a / b
ZeroDivisionError: division by zero

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

Иерархия исключений в 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

Как видно из приведенной выше схемы, все исключения являются подклассом исключения BaseException. Более подробно об иерархии исключений и их описании можете прочитать здесь.

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

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

print("start")
try:
   val = int(input("input number: "))
   tmp = 10 / val
   print(tmp)
except Exception as e:
   print("Error! " + str(e))
print("stop")

В приведенной выше программе возможных два вида исключений – это ValueError, возникающее в случае, если на запрос программы “введите число”, вы введете строку, и ZeroDivisionError – если вы введете в качестве числа 0.

Вывод программы при вводе нулевого числа будет таким.

start input number: 0 Error! stop

Если бы инструкций try…except не было, то при выбросе любого из исключений программа аварийно завершится.

print("start")
val = int(input(“input number: “))
tmp = 10 / val
print(tmp)
print("stop")

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

start

input number: 0

Traceback (most recent call last):

File “F:/work/programming/python/devpractice/tmp.py”, line 3, in <module>

tmp = 10 / val

ZeroDivisionError: division by zero

Обратите внимание, надпись stop уже не печатается в конце вывода программы.

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

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

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

Если бы мы в нашей программе хотели обрабатывать только ValueError и ZeroDivisionError, то программа выглядела бы так.

print("start")
try:
   val = int(input("input number: "))
   tmp = 10 / val
   print(tmp)
except(ValueError, ZeroDivisionError):
   print("Error!")
print("stop")

Или так, если хотим обрабатывать ValueError, ZeroDivisionError по отдельность, и, при этом, сохранить работоспособность при возникновении исключений отличных от вышеперечисленных.

print("start")
try:
   val = int(input("input number: "))
   tmp = 10 / val
   print(tmp)
except ValueError:
   print("ValueError!")
except ZeroDivisionError:
   print("ZeroDivisionError!")
except:
   print("Error!")
print("stop")

Существует возможность передать подробную информацию о произошедшем исключении в код внутри блока except.

rint("start")
try:
   val = int(input("input number: "))
   tmp = 10 / val
   print(tmp)
except ValueError as ve:
   print("ValueError! {0}".format(ve))
except ZeroDivisionError as zde:
   print("ZeroDivisionError! {0}".format(zde))
except Exception as ex:
   print("Error! {0}".format(ex))
print("stop")

Использование finally в обработке исключений

Для выполнения определенного программного кода при выходе из блока try/except, используйте оператор finally.

try:
   val = int(input("input number: "))
   tmp = 10 / val
   print(tmp)
except:
   print("Exception")
finally:
  print("Finally code")

Не зависимо от того, возникнет или нет во время выполнения кода в блоке try исключение, код в блоке finally все равно будет выполнен.

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

try:
   f = open("tmp.txt", "r")
   for line in f:
       print(line)
   f.close()
except Exception as e:
   print(e)
else:
   print("File was readed")

Генерация исключений в Python

Для принудительной генерации исключения используется инструкция raise.

Самый простой пример работы с raise может выглядеть так.

try:
   raise Exception("Some exception")
except Exception as e:
   print("Exception exception " + str(e))

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

Пользовательские исключения (User-defined Exceptions) в Python

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

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

class NegValException(Exception):
   pass

try:
   val = int(input("input positive number: "))
   if val < 0:
       raise NegValException("Neg val: " + str(val))
   print(val + 10)
except NegValException as e:
  print(e)

P.S.

Если вам интересна тема анализа данных, то мы рекомендуем ознакомиться с библиотекой Pandas. На нашем сайте вы можете найти вводные уроки по этой теме. Все уроки по библиотеке Pandas собраны в книге “Pandas. Работа с данными”.
Книга: Pandas. Работа с данными

<<< Python. Урок 10. Функции в Python Python. Урок 12. Ввод-вывод данных. Работа с файлами>>>

Содержание:развернуть

Как устроен механизм исключений
Как обрабатывать исключения в Python (try except)
As — сохраняет ошибку в переменную
Finally — выполняется всегда
Else — выполняется когда исключение не было вызвано
Несколько блоков except
Несколько типов исключений в одном блоке except
Raise — самостоятельный вызов исключений
Как пропустить ошибку
Исключения в lambda функциях
20 типов встроенных исключений в Python
Как создать свой тип Exception

Программа, написанная на языке Python, останавливается сразу как обнаружит ошибку. Ошибки могут быть (как минимум) двух типов:

Синтаксические ошибки — возникают, когда написанное выражение не соответствует правилам языка (например, написана лишняя скобка);
Исключения — возникают во время выполнения программы (например, при делении на ноль).

Синтаксические ошибки исправить просто (если вы используете IDE, он их подсветит). А вот с исключениями всё немного сложнее — не всегда при написании программы можно сказать возникнет или нет в данном месте исключение. Чтобы приложение продолжило работу при возникновении проблем, такие ошибки нужно перехватывать и обрабатывать с помощью блока try/except.

Как устроен механизм исключений

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

💁‍♂️ Пример: напишем скрипт, в котором функция ожидает число, а мы передаём сроку (это вызовет исключение «TypeError»):

def b(value): print("-> b") print(value + 1) # ошибка тут


def a(value):

print("-> a")

b(value)
a("10")

> -> a > -> b > Traceback (most recent call last): > File "test.py", line 11, in <module> > a("10") > File "test.py", line 8, in a > b(value) > File "test.py", line 3, in b > print(value + 1) > TypeError: can only concatenate str (not "int") to str

В данном примере мы запускаем файл «test.py» (через консоль). Вызывается функция «a«, внутри которой вызывается функция «b«. Все работает хорошо до сточки print(value + 1). Тут интерпретатор понимает, что нельзя конкатенировать строку с числом, останавливает выполнение программы и вызывает исключение «TypeError».

Далее ошибка передается по цепочке в обратном направлении: «b» → «a» → «test.py«. Так как в данном примере мы не позаботились обработать эту ошибку, вся информация по ошибке отобразится в консоли в виде Traceback.

Traceback (трассировка) — это отчёт, содержащий вызовы функций, выполненные в определенный момент. Трассировка помогает узнать, что пошло не так и в каком месте это произошло.

Traceback лучше читать снизу вверх ↑

Пример Traceback в Python

В нашем примере Traceback содержится следующую информацию (читаем снизу вверх):

TypeError — тип ошибки (означает, что операция не может быть выполнена с переменной этого типа);
can only concatenate str (not "int") to str — подробное описание ошибки (конкатенировать можно только строку со строкой);
Стек вызова функций (1-я линия — место, 2-я линия — код). В нашем примере видно, что в файле «test.py» на 11-й линии был вызов функции «a» со строковым аргументом «10». Далее был вызов функции «b». print(value + 1) это последнее, что было выполнено — тут и произошла ошибка.
most recent call last — означает, что самый последний вызов будет отображаться последним в стеке (в нашем примере последним выполнился print(value + 1)).

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

Как обрабатывать исключения в Python (try except)

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

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

try: a = 7 / 0 except: print('Ошибка! Деление на 0')

Здесь в блоке try находится код a = 7 / 0 — при попытке его выполнить возникнет исключение и выполнится код в блоке except (то есть будет выведено сообщение «Ошибка! Деление на 0»). После этого программа продолжит свое выполнение.

💭 PEP 8 рекомендует, по возможности, указывать конкретный тип исключения после ключевого слова except (чтобы перехватывать и обрабатывать конкретные исключения):

try: a = 7 / 0 except ZeroDivisionError: print('Ошибка! Деление на 0')

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

try: a = 7 / 0 except Exception: print('Любая ошибка!')

As — сохраняет ошибку в переменную

Перехваченная ошибка представляет собой объект класса, унаследованного от «BaseException». С помощью ключевого слова as можно записать этот объект в переменную, чтобы обратиться к нему внутри блока except:

try: file = open('ok123.txt', 'r') except FileNotFoundError as e: print(e)

> [Errno 2] No such file or directory: 'ok123.txt'

В примере выше мы обращаемся к объекту класса «FileNotFoundError» (при выводе на экран через print отобразится строка с полным описанием ошибки).

У каждого объекта есть поля, к которым можно обращаться (например если нужно логировать ошибку в собственном формате):

import datetime


now = datetime.datetime.now().strftime("%d-%m-%Y %H:%M:%S")
try:

file = open('ok123.txt', 'r')

except FileNotFoundError as e:

print(f"{now} [FileNotFoundError]: {e.strerror}, filename: {e.filename}")

> 20-11-2021 18:42:01 [FileNotFoundError]: No such file or directory, filename: ok123.txt

Finally — выполняется всегда

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

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

В следующем примере откроем файл и обратимся к несуществующей строке:

file = open('ok.txt', 'r')


try:

lines = file.readlines()

print(lines[5])

finally:

file.close()

if file.closed:

print("файл закрыт!")

> файл закрыт! > Traceback (most recent call last): > File "test.py", line 5, in <module> > print(lines[5]) > IndexError: list index out of range

Даже после исключения «IndexError», сработал код в секции finally, который закрыл файл.

p.s. данный пример создан для демонстрации, в реальном проекте для работы с файлами лучше использовать менеджер контекста with.

Также можно использовать одновременно три блока try/except/finally. В этом случае:

в try — код, который может вызвать исключения;
в except — код, который должен выполниться при возникновении исключения;
в finally — код, который должен выполниться в любом случае.

def sum(a, b): res = 0


    try:

res = a + b

except TypeError:

res = int(a) + int(b)

finally:

print(f"a = {a}, b = {b}, res = {res}")
sum(1, "2")

> a = 1, b = 2, res = 3

Else — выполняется когда исключение не было вызвано

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

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

b = int(input('b = ')) c = int(input('c = ')) try: a = b / c except ZeroDivisionError: print('Ошибка! Деление на 0') else: print(f"a = {a}")

> b = 10 > c = 1 > a = 10.0

В этом случае, если пользователь присвоит переменной «с» ноль, то появится исключение и будет выведено сообщение «‘Ошибка! Деление на 0′», а код внутри блока else выполняться не будет. Если ошибки не будет, то на экране появятся результаты деления.

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

В программе может возникнуть несколько исключений, например:

Ошибка преобразования введенных значений к типу float («ValueError»);
Деление на ноль («ZeroDivisionError»).

В Python, чтобы по-разному обрабатывать разные типы ошибок, создают несколько блоков except:

try: b = float(input('b = ')) c = float(input('c = ')) a = b / c except ZeroDivisionError: print('Ошибка! Деление на 0') except ValueError: print('Число введено неверно') else: print(f"a = {a}")


> b = 10

> c = 0

> Ошибка! Деление на 0

> b = 10 > c = питон > Число введено неверно

Теперь для разных типов ошибок есть свой обработчик.

Несколько типов исключений в одном блоке except

Можно также обрабатывать в одном блоке except сразу несколько исключений. Для этого они записываются в круглых скобках, через запятую сразу после ключевого слова except. Чтобы обработать сообщения «ZeroDivisionError» и «ValueError» в одном блоке записываем их следующим образом:

try: b = float(input('b = ')) c = float(input('c = ')) a = b / c except (ZeroDivisionError, ValueError) as er: print(er) else: print('a = ', a)

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

Raise — самостоятельный вызов исключений

Исключения можно генерировать самостоятельно — для этого нужно запустить оператор raise.

min = 100 if min > 10: raise Exception('min must be less than 10')

> Traceback (most recent call last): > File "test.py", line 3, in <module> > raise Exception('min value must be less than 10') > Exception: min must be less than 10

Перехватываются такие сообщения точно так же, как и остальные:

min = 100


try:

if min > 10:

raise Exception('min must be less than 10')

except Exception:

print('Моя ошибка')

> Моя ошибка

Кроме того, ошибку можно обработать в блоке except и пробросить дальше (вверх по стеку) с помощью raise:

min = 100


try:

if min > 10:

raise Exception('min must be less than 10')

except Exception:

print('Моя ошибка')

raise

> Моя ошибка > Traceback (most recent call last): > File "test.py", line 5, in <module> > raise Exception('min must be less than 10') > Exception: min must be less than 10

Как пропустить ошибку

Иногда ошибку обрабатывать не нужно. В этом случае ее можно пропустить с помощью pass:

try: a = 7 / 0 except ZeroDivisionError: pass

Исключения в lambda функциях

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

20 типов встроенных исключений в Python

Иерархия классов для встроенных исключений в Python выглядит так:

BaseException SystemExit KeyboardInterrupt GeneratorExit Exception ArithmeticError AssertionError ... ... ... ValueError Warning

Все исключения в Python наследуются от базового BaseException:

SystemExit — системное исключение, вызываемое функцией sys.exit() во время выхода из приложения;
KeyboardInterrupt — возникает при завершении программы пользователем (чаще всего при нажатии клавиш Ctrl+C);
GeneratorExit — вызывается методом close объекта generator;
Exception — исключения, которые можно и нужно обрабатывать (предыдущие были системными и их трогать не рекомендуется).

От Exception наследуются:

1 StopIteration — вызывается функцией next в том случае если в итераторе закончились элементы;

2 ArithmeticError — ошибки, возникающие при вычислении, бывают следующие типы:

FloatingPointError — ошибки при выполнении вычислений с плавающей точкой (встречаются редко);
OverflowError — результат вычислений большой для текущего представления (не появляется при операциях с целыми числами, но может появиться в некоторых других случаях);
ZeroDivisionError — возникает при попытке деления на ноль.

3 AssertionError — выражение, используемое в функции assert неверно;

4 AttributeError — у объекта отсутствует нужный атрибут;

5 BufferError — операция, для выполнения которой требуется буфер, не выполнена;

6 EOFError — ошибка чтения из файла;

7 ImportError — ошибка импортирования модуля;

8 LookupError — неверный индекс, делится на два типа:

IndexError — индекс выходит за пределы диапазона элементов;
KeyError — индекс отсутствует (для словарей, множеств и подобных объектов);

9 MemoryError — память переполнена;

10 NameError — отсутствует переменная с данным именем;

11 OSError — исключения, генерируемые операционной системой:

ChildProcessError — ошибки, связанные с выполнением дочернего процесса;
ConnectionError — исключения связанные с подключениями (BrokenPipeError, ConnectionResetError, ConnectionRefusedError, ConnectionAbortedError);
FileExistsError — возникает при попытке создания уже существующего файла или директории;
FileNotFoundError — генерируется при попытке обращения к несуществующему файлу;
InterruptedError — возникает в том случае если системный вызов был прерван внешним сигналом;
IsADirectoryError — программа обращается к файлу, а это директория;
NotADirectoryError — приложение обращается к директории, а это файл;
PermissionError — прав доступа недостаточно для выполнения операции;
ProcessLookupError — процесс, к которому обращается приложение не запущен или отсутствует;
TimeoutError — время ожидания истекло;

12 ReferenceError — попытка доступа к объекту с помощью слабой ссылки, когда объект не существует;

13 RuntimeError — генерируется в случае, когда исключение не может быть классифицировано или не подпадает под любую другую категорию;

14 NotImplementedError — абстрактные методы класса нуждаются в переопределении;

15 SyntaxError — ошибка синтаксиса;

16 SystemError — сигнализирует о внутренне ошибке;

17 TypeError — операция не может быть выполнена с переменной этого типа;

18 ValueError — возникает когда в функцию передается объект правильного типа, но имеющий некорректное значение;

19 UnicodeError — исключение связанное с кодирование текста в unicode, бывает трех видов:

UnicodeEncodeError — ошибка кодирования;
UnicodeDecodeError — ошибка декодирования;
UnicodeTranslateError — ошибка перевода unicode.

20 Warning — предупреждение, некритическая ошибка.

💭 Посмотреть всю цепочку наследования конкретного типа исключения можно с помощью модуля inspect:

import inspect


print(inspect.getmro(TimeoutError))

> (<class 'TimeoutError'>, <class 'OSError'>, <class 'Exception'>, <class 'BaseException'>, <class 'object'>)

📄 Подробное описание всех классов встроенных исключений в Python смотрите в официальной документации.

Как создать свой тип Exception

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

class MyError(Exception): def __init__(self, text): self.txt = text


try:

raise MyError('Моя ошибка')

except MyError as er:

print(er)

> Моя ошибка

С помощью try/except контролируются и обрабатываются ошибки в приложении. Это особенно актуально для критически важных частей программы, где любые «падения» недопустимы (или могут привести к негативным последствиям). Например, если программа работает как «демон», падение приведет к полной остановке её работы. Или, например, при временном сбое соединения с базой данных, программа также прервёт своё выполнение (хотя можно было отловить ошибку и попробовать соединиться в БД заново).

Вместе с try/except можно использовать дополнительные блоки. Если использовать все блоки описанные в статье, то код будет выглядеть так:

try: # попробуем что-то сделать except (ZeroDivisionError, ValueError) as e: # обрабатываем исключения типа ZeroDivisionError или ValueError except Exception as e: # исключение не ZeroDivisionError и не ValueError # поэтому обрабатываем исключение общего типа (унаследованное от Exception) # сюда не сходят исключения типа GeneratorExit, KeyboardInterrupt, SystemExit else: # этот блок выполняется, если нет исключений # если в этом блоке сделать return, он не будет вызван, пока не выполнился блок finally finally: # этот блок выполняется всегда, даже если нет исключений else будет проигнорирован # если в этом блоке сделать return, то return в блоке

Подробнее о работе с исключениями в Python можно ознакомиться в официальной документации.

Источник

Рассказывает команда SimbirSoft

Для обозначения базовых типов переменных используются сами типы:

str
int
float
bool
complex
bytes
etc.

Пример использования базовых типов в python-функции:

def func(a: int, b: float) -> str:  
    a: str = f"{a}, {b}"  
    return a

Пример кода:

from typing import List  
  
def func(n: int) -> List[int]:  
    return list(range(n))

Set[x]
FrozenSet[x]
ByteString[x]
Dict[x, y]
DefaultDict[x, y]
OrderedDict[x, y]
ChainMap[x,y]
Counter[x, int]
Deque[x]
и т.д.

Также есть более абстрактные типы, например:

Mapping[x, y] – объект имеет реализации метода __getitem__;
Iterable[x] – объект имеет реализацию метода __iter__.

from typing import Callable  

def func(f: Callable[[int, int], bool]) -> bool:  
    return f(1,2)  
                                                                                
func(lambda x, y: x == y)                                                      
>>> False

Тип Callable:

говорит о том, что у объекта реализован метод __call__;
описывает типы параметров к этому методу.

На первом месте стоит массив типов входных параметров, на втором — тип возвращаемого значения.

Про остальные абстрактные типы контейнеров можно прочитать в документации Python.

Также Python позволяет определять свои Generic-типы.

from typing import TypeVar, Generic  
     
T = TypeVar('T')  
   
class Stack(Generic[T]):  
    def __init__(self) -> None:  
        # Create an empty list with items of type T  
        self.items: List[T] = []  
   
    def push(self, item: T) -> None:  
        self.items.append(item)  
 
    def pop(self) -> T:  
        return self.items.pop()  

    def empty(self) -> bool:  
        return not self.items

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

def func(stack: Stack[int]) -> None:  
     stack.push(11)  
     stack.push(-2)  
                                                                                  
s = Stack[int]()                                                               
func(s)                                                                        
s.empty()                                                                      
>>> False

s.items                                                                        
>>> [11, -2]

from typing import Generic, TypeVar, Mapping, Iterator, Dict  
   
KeyType = TypeVar('KeyType')  
ValueType = TypeVar('ValueType')  

class MyMap(Mapping[KeyType, ValueType]):  # This is a generic subclass of Mapping  
    def __getitem__(self, k: KeyType) -> ValueType:  
        ...  # Implementations omitted  
    def __iter__(self) -> Iterator[KeyType]:  
        ...  
    def __len__(self) -> int:  
        ...

На месте KeyType или ValueType могут быть конкретные типы.

Зачем это нужно

Допустим, у вас есть класс юзера и функция, которая преобразует json в User.

from typing import Dict, Union, Optional                                        

from dataclasses import dataclass                                               

@dataclass  
class User:  
    name: str  
    surname: str  
    age: int                                                                        

def get_user_from_json(json_dict: Dict[str, Optional[Union[int, str]]]) -> User:  
    name = json_dict.get("name")  
    surname = json_dict.get("surname")  
    age = json_dict.get("age")  
    if (age is None or  
        name is None or  
        surname is None):  
        raise ValueError("Not enough information")  
    return User(age=age, name=name, surname=surname)

Конечно, можно написать и проще:

def get_user_from_json(json_dict: Dict[str, Optional[Union[int, str]]]) -> User:  
    return User(age=json_dict["age"], name=json_dict["name"], surname=json_dict["surname"])

from pydantic import BaseModel                                                 

class User(BaseModel):  
    name: str  
    surname: str  
    age: int  
                                                                              

def get_user_from_json(json_dict: Dict[str, Optional[Union[int, str]]]) -> User:  
    return User(**json_dict)                                                                               

get_user_from_json({  
    "name": "ssa",  
    "surname": "ddd",  
    "age": 10  
})                                                                             
>>> User(name='ssa', surname='ddd', age=10)

get_user_from_json({  
    "name": "ssa",  
    "surname": "ddd",  
    "age": "10"  
 })                                                                             
>>> User(name='ssa', surname='ddd', age=10)

get_user_from_json({  
    "name": "ssa",  
    "surname": "ddd",  
    "age": "d"  
})
--------------------------------------
ValidationError: 1 validation error for User
age
 value is not a valid integer (type=type_error.integer)

from pydantic import BaseModel, validator                                                   

class User(BaseModel):  
    name: str  
    age: int  

    @validator('age')  
    def validate_age(cls, value):  
        if int(value) < 10:  
            raise ValueError("too low")  
        return str(value)  
                                                                                       
User(name='Brian', age=33)                                                                  
>>> User(name='Brian', age='33')

from fastapi import FastAPI  
from typing import Optional  
from pydantic import BaseModel  
   
app = FastAPI()  

class Item(BaseModel):  
    name: str  
    price: float  
    is_offer: Optional[bool] = None  

@app.put("/item")  
async def put_item(item: Item):  
    return {"item_name": item.name, "item_price": item.price}

Нововведения Python 3.9.0

Заключение

Синтаксис обработки исключений

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

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

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

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

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

a = 8
b = 10
c = a b

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

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

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

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

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

Исключения

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

Ошибка типа (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.

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

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

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

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

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

Исключение KeyboardInterrupt

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

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

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

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

Деление на ноль (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)

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

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

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

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

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)

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

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

Ошибка ключа

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

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

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

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

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)

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)

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

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

Пользовательские исключения в 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

Недостатки обработки исключений в 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

Выводы!

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

Время прочтения
9 мин

Просмотры 7K

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

→ Первая часть

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

Вот что происходит при подготовке Python-кода к выполнению: «В Python исходный код преобразуется, с использованием CPython, в гораздо более простую форму, называемую байт-кодом. Байт-код состоит из инструкций, которые, по своей сути, похожи на процессорные инструкции. Но они выполняются не процессором, а программной системой, которая называется виртуальной машиной. (Здесь речь идёт не о тех виртуальных машинах, возможности которых позволяют запускать в них целые операционные системы. В нашем случае это среда, которая представляет собой упрощённую версию окружения, доступного программам, выполняемым на процессоре)».

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

Например, Python считает строкой всё, что заключено в одинарные или двойные кавычки. Если Python встречает число — он считает, что соответствующее значение имеет числовой тип. Если мы попытаемся сделать с некоей сущностью что-то такое, что нельзя делать с сущностью её типа, Python сообщит нам об этом позже.

Рассмотрим следующее сообщение об ошибке, выводящееся при попытке сложить строку и число:

name = 'Vicki'
seconds = 4.71;

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-9-71805d305c0b> in <module>
      3 
      4 
----> 5 name + seconds

TypeError: must be str, not float

Система сообщает нам о том, что она не может складывать строки и числа с плавающей точкой. При этом то, что name — это строка, а seconds — это число, не интересовало систему до тех пор, пока не была выполнена попытка сложить name и seconds.

Другими словами, это можно описать так: «Утиная типизация используется при выполнении сложения. Python не интересует то, какой именно тип имеет некий объект. Всё, что интересует систему — это то, возвращает ли что-то осмысленное вызов метода сложения. Если это не так — выдаётся ошибка».

Что бы это значило? Это значит, что мы, если пишем программы на Python, не получим сообщение об ошибке до тех пор, пока интерпретатор CPython не займётся выполнением той самой строки, в которой имеется ошибка.

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

Собственно говоря, тут мы и подходим к разговору об аннотациях типов в Python.

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

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

def train(args, model, device, train_loader, optimizer, epoch):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()
        output = model(data)
        loss = F.nll_loss(output, target)
        loss.backward()
        optimizer.step()
        if batch_idx % args.log_interval == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]tLoss: {:.6f}'.format(
                epoch, batch_idx * len(data), len(train_loader.dataset),
100. * batch_idx / len(train_loader), loss.item()))

Что такое model? Мы, конечно, можем покопаться в кодовой базе и это выяснить:

model = Net().to(device)

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

def train(args, model (type Net), device, train_loader, optimizer, epoch):

А как насчёт device? Если порыться в коде — можно выяснить следующее:

device = torch.device("cuda" if use_cuda else "cpu")

Теперь перед нами встаёт вопрос о том, что такое torch.device. Это — специальный тип PyTorch. Его описание можно найти в соответствующем разделе документации к PyTorch.

Хорошо было бы, если бы мы могли указать тип device в списке аргументов функции. Тем самым мы сэкономили бы немало времени тому, кому пришлось бы анализировать этот код.

def train(args, model (type Net), device (type torch.Device), train_loader, optimizer, epoch):

Эти рассуждения можно продолжать ещё очень долго.

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

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

Аннотации типов в Python

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

Подобный код изначально выглядел так:

users = [] # type: List[UserID]
examples = {} # type: Dict[str, Any]

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

Далее, началась работа над PEP 484. Этот документ, посвящённый аннотациям типов, разрабатывался в тесной связи с mypy — проектом DropBox, который направлен на проверку типов перед запуском скриптов. Пользуясь mypy, стоит помнить о том, что проверка типов не производится во время выполнения скрипта. Сообщение об ошибке во время выполнения можно получить если, например, попробовать сделать со значением некоего типа то, что этот тип не поддерживает. Скажем — если попытаться сделать срез словаря или вызвать метод .pop() для строки.

Вот что можно узнать из PEP 484 о деталях реализации аннотаций: «Хотя эти аннотации доступны во время выполнения программы через обычный атрибут annotations, во время выполнения проверки типов не производятся. Вместо этого данное предложение предусматривает существование отдельного самостоятельного инструмента для проверки типов, с помощью которого пользователь, по своему желанию, может проверять исходный код своих программ. В целом, подобный инструмент для проверки типов работает как очень мощный линтер. (Хотя, конечно, отдельные пользователи могут применить похожий инструмент для проверки типов и во время выполнения программы — ради реализации методологии Design By Contract, или ради выполнения JIT-оптимизации. Но надо отметить, что подобные инструменты пока не достигли достаточной зрелости».

Как же выглядит работа с аннотациями типов на практике?

Например, их применение означает возможность облегчения работы в различных IDE. Так, PyCharm, предлагает, на базе сведений о типах, автозавершение кода и выполнение его проверок. Похожие возможности имеются и в VS Code.

Аннотации типов полезны и по ещё одной причине: они защищают разработчика от глупых ошибок. Вот отличный пример подобной защиты.

Предположим, мы добавляем в словарь имена людей:

names = {'Vicki': 'Boykis',
         'Kim': 'Kardashian'}

def append_name(dict, first_name, last_name):
    dict[first_name] = last_name
    

append_name(names,'Kanye',9)

Если мы подобное позволим — в словаре окажется множество неправильно сформированных записей.
Исправим это:

from typing import Dict 

names_new: Dict[str, str] = {'Vicki': 'Boykis',
                             'Kim': 'Kardashian'}

def append_name(dic: Dict[str, str] , first_name: str, last_name: str):
    dic[first_name] = last_name

append_name(names_new,'Kanye',9.7)

names_new

Теперь проверим этот код с помощью mypy и получим следующее:

(kanye) mbp-vboykis:types vboykis$ mypy kanye.py
kanye.py:9: error: Argument 3 to "append_name" has incompatible type "float"; expected "str"

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

Подсказки типов в различных IDE

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

Например, предположим, что у вас имеется фрагмент кода, напоминающий следующий. Это — пара функций из предыдущих примеров, обёрнутых в классы.

from typing import Dict

class rainfallRate:

    def __init__(self, hours, inches):
        self.hours= hours
        self.inches = inches


    def calculateRate(self, inches:int, hours:int) -> float:
        return inches/hours


rainfallRate.calculateRate()


class addNametoDict:

    def __init__(self, first_name, last_name):
        self.first_name = first_name
        self.last_name = last_name
        self.dict = dict

    def append_name(dict:Dict[str, str], first_name:str, last_name:str):
        dict[first_name] = last_name

addNametoDict.append_name()

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

Подсказки по типам в IDE

Начало работы с аннотациями типов

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

Начните с малого — добейтесь того, чтобы некоторые файлы, содержащие несколько аннотаций, проходили бы проверку с помощью mypy.
Напишите скрипт для запуска mypy. Это поможет добиться единообразных результатов испытаний.
Запускайте mypy в CI-конвейерах для предотвращения ошибок, связанных с типами.
Постепенно аннотируйте модули, которые используются в проекте чаще всего.
Добавляйте аннотации типов в существующий код, который вы модифицируете; оснащайте ими новый код, который пишете.
Используйте MonkeyType или PyAnnotate для автоматического аннотирования старого кода.

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

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

Во-вторых, этот модуль даёт возможность работать с несколькими сложными типами. Среди них — Dict, Tuple, List и Set. Конструкция вида Dict[str, float] означает, что вы хотите работать со словарём, в элементах которого, в качестве ключа, используется строка, а в качестве значения — число с плавающей точкой. Ещё существуют типы, которые называются Optional и Union.

В-третьих — вам нужно ознакомиться с форматом аннотаций типов:

import typing

def some_function(variable: type) -> return_type:
  do_something

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

Итоги. Стоит ли пользоваться аннотациями типов в Python?

Сейчас давайте зададимся вопросом о том, стоит ли вам пользоваться аннотациями типов в Python. На самом деле, это зависит от особенностей вашего проекта. Вот что по этому поводу говорит Гвидо ван Россум в документации к mypy: «Цель mypy заключается не в том, чтобы убедить всех в необходимости писать статически типизированный Python-код. Статическая типизация — это, и сейчас, и в будущем, совершенно необязательно. Цель mypy заключается в том, чтобы дать Python-программистам больше возможностей. В том, чтобы сделать Python более конкурентоспособной альтернативой другим статически типизированным языкам, используемым в больших проектах. В том, чтобы повысить производительность труда программистов и улучшить качество программного обеспечения».

Затраты времени, нужные для настройки mypy и для планирования типов, необходимых для некоей программы, не оправдывают себя в маленьких проектах и при проведении экспериментов (например, производимых в Jupyter). Какой проект считать маленьким? Вероятно, такой, объём которого, по осторожным подсчётам, не превышает 1000 строк.

Аннотации типов имеют смысл в более крупных проектах. Там они могут, в частности, сэкономить немало времени. Речь идёт о проектах, разрабатываемых группами программистов, о пакетах, о коде, при разработке которого используются системы контроля версий и CI-конвейеры.

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

Уважаемые читатели! Пользуетесь ли вы аннотациями типов в своих Python-проектах?

Содержание:развернуть

Как устроен механизм исключений
Как обрабатывать исключения в Python (try except)
As — сохраняет ошибку в переменную
Finally — выполняется всегда
Else — выполняется когда исключение не было вызвано
Несколько блоков except
Несколько типов исключений в одном блоке except
Raise — самостоятельный вызов исключений
Как пропустить ошибку
Исключения в lambda функциях
20 типов встроенных исключений в Python
Как создать свой тип Exception

Синтаксические ошибки — возникают, когда написанное выражение не соответствует правилам языка (например, написана лишняя скобка);
Исключения — возникают во время выполнения программы (например, при делении на ноль).

Как устроен механизм исключений

def b(value): print("-> b") print(value + 1) # ошибка тут


def a(value):

print("-> a")

b(value)
a("10")

Traceback лучше читать снизу вверх ↑

Пример Traceback в Python

В нашем примере Traceback содержится следующую информацию (читаем снизу вверх):

TypeError — тип ошибки (означает, что операция не может быть выполнена с переменной этого типа);
can only concatenate str (not "int") to str — подробное описание ошибки (конкатенировать можно только строку со строкой);
Стек вызова функций (1-я линия — место, 2-я линия — код). В нашем примере видно, что в файле «test.py» на 11-й линии был вызов функции «a» со строковым аргументом «10». Далее был вызов функции «b». print(value + 1) это последнее, что было выполнено — тут и произошла ошибка.
most recent call last — означает, что самый последний вызов будет отображаться последним в стеке (в нашем примере последним выполнился print(value + 1)).

Как обрабатывать исключения в Python (try except)

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

try: a = 7 / 0 except: print('Ошибка! Деление на 0')

try: a = 7 / 0 except ZeroDivisionError: print('Ошибка! Деление на 0')

try: a = 7 / 0 except Exception: print('Любая ошибка!')

As — сохраняет ошибку в переменную

try: file = open('ok123.txt', 'r') except FileNotFoundError as e: print(e)

> [Errno 2] No such file or directory: 'ok123.txt'

import datetime


now = datetime.datetime.now().strftime("%d-%m-%Y %H:%M:%S")
try:

file = open('ok123.txt', 'r')

except FileNotFoundError as e:

print(f"{now} [FileNotFoundError]: {e.strerror}, filename: {e.filename}")

> 20-11-2021 18:42:01 [FileNotFoundError]: No such file or directory, filename: ok123.txt

Finally — выполняется всегда

В следующем примере откроем файл и обратимся к несуществующей строке:

file = open('ok.txt', 'r')


try:

lines = file.readlines()

print(lines[5])

finally:

file.close()

if file.closed:

print("файл закрыт!")

> файл закрыт! > Traceback (most recent call last): > File "test.py", line 5, in <module> > print(lines[5]) > IndexError: list index out of range

Даже после исключения «IndexError», сработал код в секции finally, который закрыл файл.

p.s. данный пример создан для демонстрации, в реальном проекте для работы с файлами лучше использовать менеджер контекста with.

Также можно использовать одновременно три блока try/except/finally. В этом случае:

в try — код, который может вызвать исключения;
в except — код, который должен выполниться при возникновении исключения;
в finally — код, который должен выполниться в любом случае.

def sum(a, b): res = 0


    try:

res = a + b

except TypeError:

res = int(a) + int(b)

finally:

print(f"a = {a}, b = {b}, res = {res}")
sum(1, "2")

> a = 1, b = 2, res = 3

Else — выполняется когда исключение не было вызвано

b = int(input('b = ')) c = int(input('c = ')) try: a = b / c except ZeroDivisionError: print('Ошибка! Деление на 0') else: print(f"a = {a}")

> b = 10 > c = 1 > a = 10.0

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

В программе может возникнуть несколько исключений, например:

Ошибка преобразования введенных значений к типу float («ValueError»);
Деление на ноль («ZeroDivisionError»).

В Python, чтобы по-разному обрабатывать разные типы ошибок, создают несколько блоков except:


> b = 10

> c = 0

> Ошибка! Деление на 0

> b = 10 > c = питон > Число введено неверно

Теперь для разных типов ошибок есть свой обработчик.

Несколько типов исключений в одном блоке except

try: b = float(input('b = ')) c = float(input('c = ')) a = b / c except (ZeroDivisionError, ValueError) as er: print(er) else: print('a = ', a)

Raise — самостоятельный вызов исключений

Исключения можно генерировать самостоятельно — для этого нужно запустить оператор raise.

min = 100 if min > 10: raise Exception('min must be less than 10')

> Traceback (most recent call last): > File "test.py", line 3, in <module> > raise Exception('min value must be less than 10') > Exception: min must be less than 10

Перехватываются такие сообщения точно так же, как и остальные:

min = 100


try:

if min > 10:

raise Exception('min must be less than 10')

except Exception:

print('Моя ошибка')

> Моя ошибка

Кроме того, ошибку можно обработать в блоке except и пробросить дальше (вверх по стеку) с помощью raise:

min = 100


try:

if min > 10:

raise Exception('min must be less than 10')

except Exception:

print('Моя ошибка')

raise

> Моя ошибка > Traceback (most recent call last): > File "test.py", line 5, in <module> > raise Exception('min must be less than 10') > Exception: min must be less than 10

Как пропустить ошибку

Иногда ошибку обрабатывать не нужно. В этом случае ее можно пропустить с помощью pass:

try: a = 7 / 0 except ZeroDivisionError: pass

Исключения в lambda функциях

20 типов встроенных исключений в Python

Иерархия классов для встроенных исключений в Python выглядит так:

BaseException SystemExit KeyboardInterrupt GeneratorExit Exception ArithmeticError AssertionError ... ... ... ValueError Warning

Все исключения в Python наследуются от базового BaseException:

SystemExit — системное исключение, вызываемое функцией sys.exit() во время выхода из приложения;
KeyboardInterrupt — возникает при завершении программы пользователем (чаще всего при нажатии клавиш Ctrl+C);
GeneratorExit — вызывается методом close объекта generator;
Exception — исключения, которые можно и нужно обрабатывать (предыдущие были системными и их трогать не рекомендуется).

От Exception наследуются:

1 StopIteration — вызывается функцией next в том случае если в итераторе закончились элементы;

2 ArithmeticError — ошибки, возникающие при вычислении, бывают следующие типы:

FloatingPointError — ошибки при выполнении вычислений с плавающей точкой (встречаются редко);
OverflowError — результат вычислений большой для текущего представления (не появляется при операциях с целыми числами, но может появиться в некоторых других случаях);
ZeroDivisionError — возникает при попытке деления на ноль.

3 AssertionError — выражение, используемое в функции assert неверно;

4 AttributeError — у объекта отсутствует нужный атрибут;

5 BufferError — операция, для выполнения которой требуется буфер, не выполнена;

6 EOFError — ошибка чтения из файла;

7 ImportError — ошибка импортирования модуля;

8 LookupError — неверный индекс, делится на два типа:

IndexError — индекс выходит за пределы диапазона элементов;
KeyError — индекс отсутствует (для словарей, множеств и подобных объектов);

9 MemoryError — память переполнена;

10 NameError — отсутствует переменная с данным именем;

11 OSError — исключения, генерируемые операционной системой:

ChildProcessError — ошибки, связанные с выполнением дочернего процесса;
ConnectionError — исключения связанные с подключениями (BrokenPipeError, ConnectionResetError, ConnectionRefusedError, ConnectionAbortedError);
FileExistsError — возникает при попытке создания уже существующего файла или директории;
FileNotFoundError — генерируется при попытке обращения к несуществующему файлу;
InterruptedError — возникает в том случае если системный вызов был прерван внешним сигналом;
IsADirectoryError — программа обращается к файлу, а это директория;
NotADirectoryError — приложение обращается к директории, а это файл;
PermissionError — прав доступа недостаточно для выполнения операции;
ProcessLookupError — процесс, к которому обращается приложение не запущен или отсутствует;
TimeoutError — время ожидания истекло;

12 ReferenceError — попытка доступа к объекту с помощью слабой ссылки, когда объект не существует;

14 NotImplementedError — абстрактные методы класса нуждаются в переопределении;

15 SyntaxError — ошибка синтаксиса;

16 SystemError — сигнализирует о внутренне ошибке;

17 TypeError — операция не может быть выполнена с переменной этого типа;

18 ValueError — возникает когда в функцию передается объект правильного типа, но имеющий некорректное значение;

19 UnicodeError — исключение связанное с кодирование текста в unicode, бывает трех видов:

UnicodeEncodeError — ошибка кодирования;
UnicodeDecodeError — ошибка декодирования;
UnicodeTranslateError — ошибка перевода unicode.

20 Warning — предупреждение, некритическая ошибка.

💭 Посмотреть всю цепочку наследования конкретного типа исключения можно с помощью модуля inspect:

import inspect


print(inspect.getmro(TimeoutError))

> (<class 'TimeoutError'>, <class 'OSError'>, <class 'Exception'>, <class 'BaseException'>, <class 'object'>)

📄 Подробное описание всех классов встроенных исключений в Python смотрите в официальной документации.

Как создать свой тип Exception

class MyError(Exception): def __init__(self, text): self.txt = text


try:

raise MyError('Моя ошибка')

except MyError as er:

print(er)

> Моя ошибка

Подробнее о работе с исключениями в Python можно ознакомиться в официальной документации.

Программа не работает. Что делать?

Проблема: Моя программа не запускается. На доли секунды появляется чёрное окошко, а затем исчезает.

Решение: запускать программу через IDLE или через консоль.

Проблема: Не работает функция input. Пишет SyntaxError.

Пример кода:

Причина: Вы запустили Python 2.

Проблема: Где-то увидел простую программу, а она не работает.

Пример кода:

Причина: Вам подсунули программу на Python 2.

Проблема: TypeError: Can’t convert ‘int’ object to str implicitly.

Пример кода:

Причина: Нельзя складывать строку с числом.

Проблема: SyntaxError: invalid syntax.

Пример кода:

Причина: Забыто двоеточие.

Проблема: SyntaxError: invalid syntax.

Пример кода:

Причина: Забыто равно.

Проблема: NameError: name ‘a’ is not defined.

Пример кода:

Причина: Переменная «a» не существует. Возможно, вы опечатались в названии или забыли инициализировать её.

Решение: Исправить опечатку.

Проблема: IndentationError: expected an indented block.

Пример кода:

Причина: Нужен отступ.

Проблема: TabError: inconsistent use of tabs and spaces in indentation.

Пример кода:

Причина: Смешение пробелов и табуляции в отступах.

Решение: Исправить отступы.

Проблема: UnboundLocalError: local variable ‘a’ referenced before assignment.

Пример кода:

Причина: Попытка обратиться к локальной переменной, которая ещё не создана.

Проблема: Программа выполнилась, но в файл ничего не записалось / записалось не всё.

Пример кода:

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

Проблема: Здесь может быть ваша проблема. Комментарии чуть ниже 🙂

Проблема с запуском файла Python

Python добавлен в PATH, и прекрасно работает в CMD.

OC — Windows 10 64Bit

Значения исключений и ошибок в Python

Синтаксис обработки исключений

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

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

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

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

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

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

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

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

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

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

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

Исключения

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Ошибка ключа

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Выводы!

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

Типизация в Python

Неявная типизация

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

a = 1  # int
b = 1.1  # float
c = 'a'  # str

def func(a: int, b: str) -> float:
    return round(float(a / len(b)), 2)


var: float = func(3, [1, 1, 1])  # 1.0

# Expected type 'str', got 'list[int]' instead

Сильная типизация

Python — язык с сильной типизацией. Это означает, что различные типы нельзя смешивать в одних выражениях.

2 + '2'
# Traceback (most recent call last):
#   File "C:main.py", line 1, in <module>
#     2 + '2'
#     ~~^~~~~
# TypeError: unsupported operand type(s) for +: 'int' and 'str'

Динамическая типизация

a = 1
a = 'a'
a = SomeClass()

a = (1, 1, 1, 3, 1, 1)
a = list(set(a))
# [1, 3]

def second(a):
    try:
        return a[1]
    except TypeError:
        return None

second([1, 2])  # 2
second('abcd')  # b
second(1)  # None

Утиная типизация

«If it looks like a duck, swims like a duck, and quacks like a duck, then it probably is a duck.»

class SomeClass:
    length = 12

    def __len__(self):
        return self.length


len('123')
# 3
len([1, 2])
# 2
len(SomeClass())
# 12
len(123)
# Traceback (most recent call last):
#   File "C:main.py", line 13, in <module>
#     len(123)
# TypeError: object of type 'int' has no len()

Заключение

Подпишитесь на новости по email

Содержание

Какие существуют виды проверки типов?
1) Что такое проверка статического типа?
2) Что такое проверка динамического типа?
3) Статически типизированные языки против динамически типизированных языков
Утиный ввод в Python
Преимущества подсказок типа
Недостатки подсказок типа
Атрибут __annotations__
Проверка типа среды выполнения
Проверка статического типа
Заключение

Какие существуют виды проверки типов?

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

Статически типизированные языки – C, Java, C ++ и т.д.
Языки с динамической типизацией – JavaScript, Python, Ruby и т.д.

1) Что такое проверка статического типа?

Тип переменной известен во время компиляции. Тип переменной фиксирован, и мы не можем изменить его позже.

Давайте посмотрим на объявление переменной в Java.

String str = "Hello";

str = 10; // Type mismatch: cannot convert from int to String 

int str = 10; // Duplicate local variable str

2) Что такое проверка динамического типа?

Давайте посмотрим на пример определения функции в Python.

def add(x, y):
    return x + y


print(add(10, 5))
print(add('A', 'B'))

3) Статически типизированные языки против динамически типизированных языков

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

Давайте посмотрим на это на примере настраиваемого объекта и функции add(), которую мы определили.

def add(x, y):
    return x + y

class Data:

    def __init__(self, i):
        self.id = i

d1 = Data(10)
d2 = Data(5)

print(add(d1, d2))

Этот код вызовет следующую ошибку времени выполнения:

Traceback (most recent call last):
  File "/Users/pankaj/Documents/PycharmProjects/hello-world/journaldev/type_checking.py", line 12, in <module>
    print(add(d1, d2))
  File "/Users/pankaj/Documents/PycharmProjects/hello-world/journaldev/type_checking.py", line 2, in add
    return x + y
TypeError: unsupported operand type(s) for +: 'Data' and 'Data'

def __add__(self, other):
    return self.id + other.id

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

def calculate(x, y, op='sum'):
    if op == 'divide':
        return x // y
    if op == 'difference':
        return x - y
    if op == 'multiply':
        return x * y
    # default is sum
    return x + y

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

print(calculate(10, 3, 'divide'))  # 3
print(calculate(10, 5))  # 15
print(calculate('A', 'B'))  # AB

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

def calculate1(x: int, y: int, op: str = 'sum') -> int:
    # same code as above

Подсказки типа аргумента функции снабжены двоеточием (:), а тип возвращаемого значения – знаком ->.

Преимущества подсказок типа

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

Недостатки подсказок типа

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

Атрибут annotations

Функции Python имеют атрибут __annotations__, который содержит информацию о подсказках типа.

def calculate(x, y, op='sum'):
    pass

def calculate1(x: int, y: int, op: str = 'sum') -> int:
    pass

print(calculate.__annotations__)  # {}

print(calculate1.__annotations__) 
# {'x': <class 'int'>, 'y': <class 'int'>, 'op': <class 'str'>, 'return': <class 'int'>}

Проверка типа среды выполнения

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

>>> x = 10
>>> type(x)
<class 'int'>
>>> 
>>> s1 = 'Hello'
>>> type(s1)
<class 'str'>
>>>

>>> x = 10
>>> isinstance(x, int)
True
>>> isinstance(x, str)
False
>>>
>>> o = object()
>>> isinstance(o, (int, str, object))
True

Проверка статического типа

pip install mypy

Допустим, у нас есть сценарий Python type_checking.py с приведенным ниже содержимым.

def calculate(x, y, op='sum'):
    pass


def calculate1(x: int, y: int, op: str = 'sum') -> int:
    pass


calculate('a', 'b')
calculate1('a', 'b')

$ mypy type_checking.py
type_checking.py:10: error: Argument 1 to "calculate1" has incompatible type "str"; expected "int"
type_checking.py:10: error: Argument 2 to "calculate1" has incompatible type "str"; expected "int"
Found 2 errors in 1 file (checked 1 source file)
$

Заключение

Исключения в языках программирования

В Python выделяют два различных вида ошибок: синтаксические ошибки и исключения.

Синтаксические ошибки в Python

>>> for i in range(10):
    prin("hello!")

Traceback (most recent call last):
  File "<pyshell#2>", line 2, in <module>
    prin("hello!")
NameError: name 'prin' is not defined

Исключения в Python

Пример исключения ZeroDivisionError, которое возникает при делении на 0.

>>> a = 10
>>> b = 0
>>> c = a / b
Traceback (most recent call last):
  File "<pyshell#5>", line 1, in <module>
    c = a / b
ZeroDivisionError: division by zero

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

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

print("start")
try:
   val = int(input("input number: "))
   tmp = 10 / val
   print(tmp)
except Exception as e:
   print("Error! " + str(e))
print("stop")

Вывод программы при вводе нулевого числа будет таким.

start input number: 0 Error! stop

Если бы инструкций try…except не было, то при выбросе любого из исключений программа аварийно завершится.

print("start")
val = int(input(“input number: “))
tmp = 10 / val
print(tmp)
print("stop")

start

input number: 0

Traceback (most recent call last):

File “F:/work/programming/python/devpractice/tmp.py”, line 3, in <module>

tmp = 10 / val

ZeroDivisionError: division by zero

Обратите внимание, надпись stop уже не печатается в конце вывода программы.

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

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

Если бы мы в нашей программе хотели обрабатывать только ValueError и ZeroDivisionError, то программа выглядела бы так.

print("start")
try:
   val = int(input("input number: "))
   tmp = 10 / val
   print(tmp)
except(ValueError, ZeroDivisionError):
   print("Error!")
print("stop")

print("start")
try:
   val = int(input("input number: "))
   tmp = 10 / val
   print(tmp)
except ValueError:
   print("ValueError!")
except ZeroDivisionError:
   print("ZeroDivisionError!")
except:
   print("Error!")
print("stop")

Существует возможность передать подробную информацию о произошедшем исключении в код внутри блока except.

rint("start")
try:
   val = int(input("input number: "))
   tmp = 10 / val
   print(tmp)
except ValueError as ve:
   print("ValueError! {0}".format(ve))
except ZeroDivisionError as zde:
   print("ZeroDivisionError! {0}".format(zde))
except Exception as ex:
   print("Error! {0}".format(ex))
print("stop")

Использование finally в обработке исключений

Для выполнения определенного программного кода при выходе из блока try/except, используйте оператор finally.

try:
   val = int(input("input number: "))
   tmp = 10 / val
   print(tmp)
except:
   print("Exception")
finally:
  print("Finally code")

try:
   f = open("tmp.txt", "r")
   for line in f:
       print(line)
   f.close()
except Exception as e:
   print(e)
else:
   print("File was readed")

Генерация исключений в Python

Для принудительной генерации исключения используется инструкция raise.

Самый простой пример работы с raise может выглядеть так.

try:
   raise Exception("Some exception")
except Exception as e:
   print("Exception exception " + str(e))

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

Пользовательские исключения (User-defined Exceptions) в Python

class NegValException(Exception):
   pass

try:
   val = int(input("input positive number: "))
   if val < 0:
       raise NegValException("Neg val: " + str(val))
   print(val + 10)
except NegValException as e:
  print(e)

P.S.

<<< Python. Урок 10. Функции в Python Python. Урок 12. Ввод-вывод данных. Работа с файлами>>>

Источник

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

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

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

Обратная трассировка в Python

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

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

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

Давайте рассмотрим простой пример.

Приведенный ниже фрагмент кода создает функцию, которая складывает два числа и умножает сумму на первое число. Затем он вызывает функцию с аргументами 5 и 4. Однако 4 передается как строка, так что на самом деле это не число.

def add_and_multiply(x, y):
    return (x + y) * x

add_and_multiply(5, "4")

Когда этот код выполняется, Python вызывает следующее исключение:

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

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

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

Например, когда я сохраняю приведенный выше фрагмент кода как «sample_script.py» и пытаюсь запустить его в терминале, я получаю следующую трассировку:

Traceback (most recent call last):
  File "/Users/sonery/sample_script.py", line 6, in <module>
    add_and_multiply(5, "6")
  File "/Users/sonery/sample_script.py", line 2, in add_and_multiply
    print((x + y) * x)
TypeError: unsupported operand type(s) for +: 'int' and 'str'

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

Распространенные типы обратной трассировки

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

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

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

Давайте рассмотрим некоторые из часто встречающихся типов ошибок в сообщениях обратной трассировки.

TypeError

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

AttributeError

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

Классы могут иметь атрибуты данных и процедурные атрибуты (т.е. методы):

Атрибуты данных: что необходимо для создания экземпляра класса
Методы (т.е. процедурные атрибуты): Как мы взаимодействуем с экземплярами класса.

Предположим, у нас есть объект типа list. Мы можем использовать метод append для добавления нового элемента в список. Если у объекта нет атрибута, который мы пытаемся использовать, возникает исключение ошибки атрибута.

Вот пример:

mylist = [1, 2, 3, 4, 5]

mylist.add(10)

# output
Traceback (most recent call last):
  File "<file>", line 3378, in run_code
    exec(code_obj, self.user_global_ns, self.user_ns)
  File "<ipython-input-25-4ad0ec665b52>", line 3, in <module>
    mylist.add(10)
AttributeError: 'list' object has no attribute 'add'

Поскольку класс list не имеет атрибута с именем “add”, мы получаем трассировку, показывающую ошибку атрибута.

ImportError и ModuleNotFoundError

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

Чтобы использовать такие библиотеки, а также встроенные библиотеки Python (например, ОС, запросы), нам необходимо их импортировать. Если при их импорте возникает проблема, возникает исключение importerror или module not found error.

Например, в следующем фрагменте кода мы пытаемся импортировать класс логистической регрессии из Scikit-learn.

from sklearn import LogisticRegression

# output
Traceback (most recent call last):
  File "<file>", line 3378, in run_code
    exec(code_obj, self.user_global_ns, self.user_ns)
  File "<ipython-input-22-b74afc1ba453>", line 1, in <module>
    from sklearn import LogisticRegression
ImportError: cannot import name 'LogisticRegression' from 'sklearn' (/Library/Frameworks/Python.framework/Versions/3.10/lib/python3.10/site-packages/sklearn/__init__.py)

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

from sklearn.linear_model import LogisticRegression

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

import openpyxl

# output
Traceback (most recent call last):
  File "<file>", line 3378, in run_code
    exec(code_obj, self.user_global_ns, self.user_ns)
  File "<ipython-input-23-f5ea1cbb6934>", line 1, in <module>
    import openpyxl
  File "/Applications/PyCharm CE.app/Contents/plugins/python-ce/helpers/pydev/_pydev_bundle/pydev_import_hook.py", line 21, in do_import
    module = self._system_import(name, *args, **kwargs)
ModuleNotFoundError: No module named 'openpyxl'

IndexError

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

names = ["John", "Jane", "Max", "Emily"]

# Get the third item
names[2]

# output
"Max"

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

names = ["John", "Jane", "Max", "Emily"]

# Get the sixth item
names[5]

# output
Traceback (most recent call last):
  File "<file>", line 3378, in run_code
    exec(code_obj, self.user_global_ns, self.user_ns)
  File "<ipython-input-30-3033b2837dcd>", line 3, in <module>
    names[5]
IndexError: list index out of range

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

Давайте рассмотрим другой пример, используя фрейм данных Pandas.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randint(10, size=(5, 2)), columns=["A", "B"])

df

# output
   A  B
0  1  6
1  6  3
2  8  8
3  3  5
4  5  6

Переменная df представляет собой DataFrame с 5 строками и 2 столбцами. Следующая строка кода пытается получить значение в третьем столбце первой строки.

df.iloc[0, 3]

# output

Traceback (most recent call last):
  File "<file>", line 3378, in run_code
    exec(code_obj, self.user_global_ns, self.user_ns)
  File "<file>", line 1, in <module>
    df.iloc[0, 3]
  File "<file>", line 960, in __getitem__
    return self.obj._get_value(*key, takeable=self._takeable)
  File "<file>", line 3612, in _get_value
    series = self._ixs(col, axis=1)
  File "<file>", line 3439, in _ixs
    label = self.columns[i]
  File "<file>", line 5039, in __getitem__
    return getitem(key)
IndexError: index 3 is out of bounds for axis 0 with size 2

Как мы видим в последней строке трассировки, это сообщение об ошибке говорит само за себя.

NameError

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

Вот пример:

members = ["John", "Jane", "Max", "Emily"]

member[0]

# output
Traceback (most recent call last):
  File "<file>", line 3378, in run_code
    exec(code_obj, self.user_global_ns, self.user_ns)
  File "<ipython-input-35-9fcefb83a26f>", line 3, in <module>
    name[5]
NameError: name 'member' is not defined

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

ValueError

Исключение ошибки значения возникает, когда мы пытаемся присвоить неправильное значение переменной. Вспомните наш DataFrame с 5 строками и 2 столбцами.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randint(10, size=(5, 2)), columns=["A", "B"])

df

# output
   A  B
0  1  6
1  6  3
2  8  8
3  3  5
4  5  6

Допустим, мы хотим добавить новый столбец в этот DataFrame.

df["C"] = [1, 2, 3, 4]

# output
Traceback (most recent call last):
  File "<file>", line 3378, in run_code
    exec(code_obj, self.user_global_ns, self.user_ns)
  File "<file>", line 1, in <module>
    df["C"] = [1, 2, 3, 4]
  File "<file>", line 3655, in __setitem__
    self._set_item(key, value)
  File "<file>", line 3832, in _set_item
    value = self._sanitize_column(value)
  File "<file>", line 4535, in _sanitize_column
    com.require_length_match(value, self.index)
  File "<file>", line 557, in require_length_match
    raise ValueError(
ValueError: Length of values (4) does not match length of index (5)

Как объясняется в сообщении об ошибке, фрейм данных содержит 5 строк, поэтому каждый столбец имеет 5 значений. Когда мы пытаемся создать новый столбец со списком из 4 элементов, мы ошибку значения.

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

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

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

Источник

Синтаксис обработки исключений

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

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

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

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

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

a = 8
b = 10
c = a b

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

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

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

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

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

Исключения

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

Ошибка типа (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.

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

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

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

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

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

Исключение KeyboardInterrupt

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

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

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

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

Деление на ноль (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)

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

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

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

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

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)

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

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

Ошибка ключа

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

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

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

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

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)

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)

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

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

Пользовательские исключения в 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

Недостатки обработки исключений в 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

Выводы!

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

Источник

Рассказывает команда SimbirSoft

Для обозначения базовых типов переменных используются сами типы:

str
int
float
bool
complex
bytes
etc.

Пример использования базовых типов в python-функции:

def func(a: int, b: float) -> str:  
    a: str = f"{a}, {b}"  
    return a

Пример кода:

from typing import List  
  
def func(n: int) -> List[int]:  
    return list(range(n))

Set[x]
FrozenSet[x]
ByteString[x]
Dict[x, y]
DefaultDict[x, y]
OrderedDict[x, y]
ChainMap[x,y]
Counter[x, int]
Deque[x]
и т.д.

Также есть более абстрактные типы, например:

Mapping[x, y] – объект имеет реализации метода __getitem__;
Iterable[x] – объект имеет реализацию метода __iter__.

from typing import Callable  

def func(f: Callable[[int, int], bool]) -> bool:  
    return f(1,2)  
                                                                                
func(lambda x, y: x == y)                                                      
>>> False

Тип Callable:

говорит о том, что у объекта реализован метод __call__;
описывает типы параметров к этому методу.

На первом месте стоит массив типов входных параметров, на втором — тип возвращаемого значения.

Про остальные абстрактные типы контейнеров можно прочитать в документации Python.

Также Python позволяет определять свои Generic-типы.

from typing import TypeVar, Generic  
     
T = TypeVar('T')  
   
class Stack(Generic[T]):  
    def __init__(self) -> None:  
        # Create an empty list with items of type T  
        self.items: List[T] = []  
   
    def push(self, item: T) -> None:  
        self.items.append(item)  
 
    def pop(self) -> T:  
        return self.items.pop()  

    def empty(self) -> bool:  
        return not self.items

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

def func(stack: Stack[int]) -> None:  
     stack.push(11)  
     stack.push(-2)  
                                                                                  
s = Stack[int]()                                                               
func(s)                                                                        
s.empty()                                                                      
>>> False

s.items                                                                        
>>> [11, -2]

from typing import Generic, TypeVar, Mapping, Iterator, Dict  
   
KeyType = TypeVar('KeyType')  
ValueType = TypeVar('ValueType')  

class MyMap(Mapping[KeyType, ValueType]):  # This is a generic subclass of Mapping  
    def __getitem__(self, k: KeyType) -> ValueType:  
        ...  # Implementations omitted  
    def __iter__(self) -> Iterator[KeyType]:  
        ...  
    def __len__(self) -> int:  
        ...

На месте KeyType или ValueType могут быть конкретные типы.

Зачем это нужно

Допустим, у вас есть класс юзера и функция, которая преобразует json в User.

from typing import Dict, Union, Optional                                        

from dataclasses import dataclass                                               

@dataclass  
class User:  
    name: str  
    surname: str  
    age: int                                                                        

def get_user_from_json(json_dict: Dict[str, Optional[Union[int, str]]]) -> User:  
    name = json_dict.get("name")  
    surname = json_dict.get("surname")  
    age = json_dict.get("age")  
    if (age is None or  
        name is None or  
        surname is None):  
        raise ValueError("Not enough information")  
    return User(age=age, name=name, surname=surname)

Конечно, можно написать и проще:

def get_user_from_json(json_dict: Dict[str, Optional[Union[int, str]]]) -> User:  
    return User(age=json_dict["age"], name=json_dict["name"], surname=json_dict["surname"])

from pydantic import BaseModel                                                 

class User(BaseModel):  
    name: str  
    surname: str  
    age: int  
                                                                              

def get_user_from_json(json_dict: Dict[str, Optional[Union[int, str]]]) -> User:  
    return User(**json_dict)                                                                               

get_user_from_json({  
    "name": "ssa",  
    "surname": "ddd",  
    "age": 10  
})                                                                             
>>> User(name='ssa', surname='ddd', age=10)

get_user_from_json({  
    "name": "ssa",  
    "surname": "ddd",  
    "age": "10"  
 })                                                                             
>>> User(name='ssa', surname='ddd', age=10)

get_user_from_json({  
    "name": "ssa",  
    "surname": "ddd",  
    "age": "d"  
})
--------------------------------------
ValidationError: 1 validation error for User
age
 value is not a valid integer (type=type_error.integer)

from pydantic import BaseModel, validator                                                   

class User(BaseModel):  
    name: str  
    age: int  

    @validator('age')  
    def validate_age(cls, value):  
        if int(value) < 10:  
            raise ValueError("too low")  
        return str(value)  
                                                                                       
User(name='Brian', age=33)                                                                  
>>> User(name='Brian', age='33')

from fastapi import FastAPI  
from typing import Optional  
from pydantic import BaseModel  
   
app = FastAPI()  

class Item(BaseModel):  
    name: str  
    price: float  
    is_offer: Optional[bool] = None  

@app.put("/item")  
async def put_item(item: Item):  
    return {"item_name": item.name, "item_price": item.price}

Нововведения Python 3.9.0

Заключение

Источник

Зачем это нужно

Нововведения Python 3.9.0

Заключение

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

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

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

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

Исключения

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

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

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

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

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

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

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

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

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

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

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

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

Ошибка ключа

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

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

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

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

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

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

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

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

Выводы!

Программа не работает. Что делать?

Значения исключений и ошибок в Python

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

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

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

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

Исключения

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

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

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

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

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

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

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

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

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

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

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

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

Ошибка ключа

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

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

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

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

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

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

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

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

Выводы!

Типизация в Python

Типизация в Python

Неявная типизация

Сильная типизация

Динамическая типизация

Утиная типизация

Заключение

Подпишитесь на новости по email

Какие существуют виды проверки типов?

1) Что такое проверка статического типа?

2) Что такое проверка динамического типа?

3) Статически типизированные языки против динамически типизированных языков

Преимущества подсказок типа

Недостатки подсказок типа

Атрибут __annotations__

Проверка типа среды выполнения

Проверка статического типа

Заключение

Исключения в языках программирования

Синтаксические ошибки в Python

Исключения в Python

Атрибут annotations