lectures/Lecture27.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "74750d32",
   "metadata": {
    "id": "74750d32",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Programming with Python\n",
    "\n",
    "## Lecture 27: Composition and exceptions\n",
    "\n",
    "### Armen Gabrielyan\n",
    "\n",
    "#### Yerevan State University\n",
    "#### Portmind"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db92142f",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Polynomial class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e15cca61",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Polynomial:\n",
    "    def __init__(self, coefficients):\n",
    "        \"\"\"\n",
    "        Initialize a Polynomial object with a list of coefficients.\n",
    "        The coefficients should be in descending order of their degrees.\n",
    "        For example, the coefficients [2, -1, 3] represent the polynomial 2 - x + 3x^2.\n",
    "        \"\"\"\n",
    "        self._coefficients = coefficients\n",
    "\n",
    "    def degree(self):\n",
    "        \"\"\"\n",
    "        Return the degree of the polynomial.\n",
    "        \"\"\"\n",
    "        return len(self._coefficients) - 1\n",
    "\n",
    "    def __add__(self, other):\n",
    "        \"\"\"\n",
    "        Add two polynomials and return a new Polynomial object representing their sum.\n",
    "        \"\"\"\n",
    "        if self.degree() >= other.degree():\n",
    "            larger_poly = self._coefficients\n",
    "            smaller_poly = other._coefficients\n",
    "        else:\n",
    "            larger_poly = other._coefficients\n",
    "            smaller_poly = self._coefficients\n",
    "\n",
    "        sum_coefficients = []\n",
    "        for i in range(len(larger_poly)):\n",
    "            if i < len(smaller_poly):\n",
    "                sum_coefficients.append(larger_poly[i] + smaller_poly[i])\n",
    "            else:\n",
    "                sum_coefficients.append(larger_poly[i])\n",
    "\n",
    "        return Polynomial(sum_coefficients)\n",
    "\n",
    "    def __mul__(self, other):\n",
    "        \"\"\"\n",
    "        Multiply two polynomials and return a new Polynomial object representing their product.\n",
    "        \"\"\"\n",
    "        product_degree = self.degree() + other.degree()\n",
    "        product_coefficients = [0] * (product_degree + 1)\n",
    "\n",
    "        for i in range(len(self._coefficients)):\n",
    "            for j in range(len(other._coefficients)):\n",
    "                product_coefficients[i + j] += self._coefficients[i] * other._coefficients[j]\n",
    "\n",
    "        return Polynomial(product_coefficients)\n",
    "\n",
    "    def __repr__(self):\n",
    "        \"\"\"\n",
    "        Return a string representation of the polynomial.\n",
    "        \"\"\"\n",
    "        terms = []\n",
    "        for i, coefficient in enumerate(self._coefficients):\n",
    "            if coefficient != 0:\n",
    "                if i == 0:\n",
    "                    terms.append(str(coefficient))\n",
    "                elif i == 1:\n",
    "                    terms.append(f\"{coefficient}x\")\n",
    "                else:\n",
    "                    terms.append(f\"{coefficient}x^{i}\")\n",
    "        return \" + \".join(terms)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3330840a",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "polynomial1 = Polynomial([2, -1, 3])\n",
    "polynomial2 = Polynomial([1, 2, -1])\n",
    "\n",
    "print(f\"p(x) = {polynomial1}\")\n",
    "print(f\"q(x) = {polynomial2}\")\n",
    "print(f\"p(x) + q(x) = {polynomial1 + polynomial2}\")\n",
    "print(f\"p(x) * q(x) = {polynomial1 * polynomial2}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e5dcaae",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Reference\n",
    "\n",
    "For more special methods, see https://docs.python.org/3/reference/datamodel.html#special-method-names."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff525bd1",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Composition\n",
    "\n",
    "**Composition** in object-oriented programming is a design principle that represents a **has-a** relationship. In composition, a composite class incorporates an object from another class called a component. Essentially, the composite class possesses a component from another class.\n",
    "\n",
    "Through composition, composite classes can reuse the functionality provided by the components they contain. Although the composite class doesn't inherit the interface of the component class, it can utilize its implementation.\n",
    "\n",
    "The composition relationship between two classes is considered loosely coupled. This means that modifications made to the component class rarely impact the composite class, and changes to the composite class do not affect the component class.\n",
    "\n",
    "This approach enhances the adaptability to change, enabling applications to introduce new requirements without disrupting existing code."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08110a4f",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "In the following example, the `Car` class has both an `Engine` and `Wheels` as its components. The `Engine` class represents the car's engine functionality, while the `Wheels` class represents the rotating wheels.\n",
    "\n",
    "When we create a `Car` object, it automatically includes an `Engine` and `Wheels` as its components through composition. The `start` method delegates the task of starting the car to the `Engine` component, and the `drive` method delegates the task of rotating the wheels to the `Wheels` component.\n",
    "\n",
    "Using composition, the `Car` class can reuse the implementation of the `Engine` and `Wheels` components. It encapsulates the functionality provided by these components and presents a higher-level interface for starting the car and driving it.\n",
    "\n",
    "This example demonstrates how composition enables objects to collaborate by combining various components to create a more complex system."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "584be354",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Engine:\n",
    "    def __init__(self, horsepower):\n",
    "        self._horsepower = horsepower\n",
    "\n",
    "    def start(self):\n",
    "        print(\"Engine started.\")\n",
    "\n",
    "    def stop(self):\n",
    "        print(\"Engine stopped.\")\n",
    "        \n",
    "    def __repr__(self):\n",
    "        class_name = type(self).__name__\n",
    "        return f\"{class_name}(horsepower={self._horsepower!r})\"\n",
    "\n",
    "class Wheels:\n",
    "    def __init__(self, size):\n",
    "        self._size = size\n",
    "\n",
    "    def rotate(self):\n",
    "        print(\"Wheels rotating.\")\n",
    "\n",
    "    def stop_rotation(self):\n",
    "        print(\"Wheels stopped.\")\n",
    "        \n",
    "    def __repr__(self):\n",
    "        class_name = type(self).__name__\n",
    "        return f\"{class_name}(size={self._size!r})\"\n",
    "\n",
    "class Car:\n",
    "    def __init__(self, engine_horsepower, wheel_size):\n",
    "        self._engine = Engine(engine_horsepower)\n",
    "        self._wheels = Wheels(wheel_size)\n",
    "\n",
    "    def start(self):\n",
    "        print(\"Starting the car...\")\n",
    "        self._engine.start()\n",
    "\n",
    "    def stop(self):\n",
    "        print(\"Stopping the car...\")\n",
    "        self._engine.stop()\n",
    "        self._wheels.stop_rotation()\n",
    "\n",
    "    def drive(self):\n",
    "        print(\"Car is driving...\")\n",
    "        self._wheels.rotate()\n",
    "    \n",
    "    def change_engine(self, new_horsepower):\n",
    "        print(\"Changing the engine...\")\n",
    "        self._engine = Engine(new_horsepower)\n",
    "\n",
    "    def change_wheel_size(self, new_size):\n",
    "        print(\"Changing wheel size...\")\n",
    "        self._wheels = Wheels(new_size)\n",
    "        \n",
    "    def __repr__(self):\n",
    "        class_name = type(self).__name__\n",
    "        return f\"{class_name}(engine={self._engine!r}, wheels={self._wheels!r})\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8668e88e",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "car = Car(200, 18)\n",
    "car"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7f18dfa5",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "car.start()\n",
    "car.drive()\n",
    "car.stop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a82aa188",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "car.change_engine(300)\n",
    "car.change_wheel_size(20)\n",
    "car"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e5191fde",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "car.start()\n",
    "car.drive()\n",
    "car.stop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b87afd8",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Errors and exceptions\n",
    "\n",
    "In Python, **errors** and **exceptions** are a way to handle unexpected situations that can occur during the execution of a program. When an error or exception occurs, the program execution is halted, and Python raises an exception object. This exception object contains information about the type of error and where it occurred in the program."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "734091f1",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Syntax errors\n",
    "\n",
    "**Syntax errors** in Python occur when the code violates the language's grammar rules. These errors prevent the code from being compiled or executed. The Python interpreter reports syntax errors by indicating the line number and providing a brief explanation of the issue."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "df6ff1c7",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Missing parentheses\n",
    "print(\"Hello, World!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bc8a6178",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Missing colon\n",
    "\n",
    "x = 42\n",
    "\n",
    "if x > 5\n",
    "    print(\"x is greater than 5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "39dba3c1",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Indentation errors\n",
    "\n",
    "x = 42\n",
    "\n",
    "if x > 5:\n",
    "print(\"x is greater than 5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49588747",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exceptions\n",
    "\n",
    "Although a statement or expression may be syntactically correct, it can still produce an error during execution. These errors, known as exceptions, are not necessarily fatal and can be handled in Python programs.\n",
    "\n",
    "The following are some examples of exception errors:\n",
    "\n",
    "- `ZeroDivisionError`: Raised when attempting to divide by zero.\n",
    "- `NameError`: It is raised when a local or global name is not found. This typically occurs when you try to use a variable or a function that hasn't been defined.\n",
    "- `TypeError`: This exception is raised when an operation or function is performed on an object of an inappropriate type. For example, trying to concatenate a string with an integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7b54963",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "result = 42 / 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0b1d3511",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "5 * fourty_two"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "efc69108",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "\"42\" + 42"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd5c6408",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Handling exceptions\n",
    "\n",
    "To handle exceptions and prevent them from terminating the program, you can use a `try-except` block. The code within the `try` block is monitored, and if an exception occurs, the corresponding `except` block is executed.\n",
    "\n",
    "```python\n",
    "try:\n",
    "    <statement(s)>\n",
    "except:\n",
    "    <statement(s)>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0eebdab6",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "The following example is a generic error handling. It handles all exception errors that can occurr in the `try` block without explicitly specifying it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "23aa96ff",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    result = 42 / 0\n",
    "except:\n",
    "    print(\"Error occurred!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "54ca9524",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    5 * fourty_two\n",
    "except:\n",
    "    print(\"Error occurred!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e1ccf80",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Also, exceptions can be handled by specifying concrete exceptions explictly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74ac7486",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    result = 42 / 0\n",
    "except ZeroDivisionError:\n",
    "    print(\"Error: Division by zero occurred!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b9ba6f2",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    5 * fourty_two\n",
    "except ZeroDivisionError:\n",
    "    print(\"Error: Division by zero occurred!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "192c1d50",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "You can have multiple `except` blocks to handle different types of exceptions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78785c5a",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    result = 42 / 0\n",
    "except ZeroDivisionError:\n",
    "    print(\"Error: Division by zero occurred!\")\n",
    "except NameError:\n",
    "    print(\"Error: Name error occurred!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4e03375",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    5 * fourty_two\n",
    "except ZeroDivisionError:\n",
    "    print(\"Error: Division by zero occurred!\")\n",
    "except NameError:\n",
    "    print(\"Error: Name error occurred!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd94b767",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Also, an `except` clause may name multiple exceptions as a parenthesized tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d263b18b",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    result = 42 / 0\n",
    "except (ZeroDivisionError, NameError):\n",
    "    print(\"Error occurred!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a2ecb706",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    5 * fourty_two\n",
    "except (ZeroDivisionError, NameError):\n",
    "    print(\"Error occurred!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "951f3a9f",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    \"42\" + 42\n",
    "except (ZeroDivisionError, NameError):\n",
    "    print(\"Error occurred!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d970997",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## The `else` clause\n",
    "\n",
    "An `else` clause might be included in a `try-catch`. It must be executed if the `try` clause does not raise an exception.\n",
    "\n",
    "```python\n",
    "try:\n",
    "    <statement(s)>\n",
    "except:\n",
    "    <statement(s)>\n",
    "else:\n",
    "    <statement(s)>\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c8303643",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    result = 42 / 0\n",
    "except ZeroDivisionError:\n",
    "    print(\"Error: Division by zero occurred!\")\n",
    "else:\n",
    "    print(f\"The result is {result}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ca3e6bf",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    result = 42 / 2\n",
    "except ZeroDivisionError:\n",
    "    print(\"Error: Division by zero occurred!\")\n",
    "else:\n",
    "    print(f\"The result is {result}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae14573a",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## The `finally` clause for cleaning up\n",
    "\n",
    "Additionally, an optional `finally` clause might be included in a `try-catch`. It must be executed under all circumstances and it is usually used for defining clean-up actions..\n",
    "\n",
    "```python\n",
    "try:\n",
    "    <statement(s)>\n",
    "except:\n",
    "    <statement(s)>\n",
    "else:\n",
    "    <statement(s)>\n",
    "finally:\n",
    "    <statement(s)> \n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3918522a",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    result = 42 / 0\n",
    "except ZeroDivisionError:\n",
    "    print(\"Error: Division by zero occurred!\")\n",
    "else:\n",
    "    print(f\"The result is {result}\")\n",
    "finally:\n",
    "    print(\"This will always execute.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "912fbfe7",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    result = 42 / 2\n",
    "except ZeroDivisionError:\n",
    "    print(\"Error: Division by zero occurred!\")\n",
    "else:\n",
    "    print(f\"The result is {result}\")\n",
    "finally:\n",
    "    print(\"This will always execute.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8dda7335",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Raising an exception\n",
    "\n",
    "The `raise` keyword in Python is used to explicitly raise an exception. The basic syntax is as follows:\n",
    "\n",
    "```python\n",
    "raise <exception>\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c0ffab48",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = 10\n",
    "if x > 5:\n",
    "    raise Exception(f\"The value of x is {x}. It should be greater than 5.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7d998d8",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "raise ValueError"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49ce90e1",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Base exceptions\n",
    "\n",
    "In Python, there is a base class for all built-in exceptions called `BaseException`. It serves as the superclass for all other exception classes and provides common functionalities and attributes for handling exceptions.\n",
    "\n",
    "`Exception`, a derived class of `BaseException`, is the base class for all non-fatal built-in exception classes and most user-defined exceptions. Exceptions that do not inherit from the `Exception` class are usually not handled as they are typically intended to signal critical errors that should cause the program to terminate (e.g. `SystemExit` and `KeyboardInterrupt`)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca6c3649",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Using `Exception` as a catch-all to handle any type of exception is possible, but it is considered a good practice to be more specific in the types of exceptions you handle. It is recommended to only catch the exceptions that you expect and handle them appropriately. Unexpected exceptions are typically allowed to propagate upwards, allowing higher-level code to handle them if needed.\n",
    "\n",
    "A common pattern when handling `Exception` is to print or log the exception information for debugging purposes and then re-raise the exception. This way, the exception can be handled at multiple levels in the code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e2c69cf1",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    \"42\" + 42\n",
    "except ZeroDivisionError:\n",
    "    print(\"Error: Division by zero occurred!\")\n",
    "except Exception as err:\n",
    "    print(f\"Unexpected {err=}, {type(err)=}\")\n",
    "    raise"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c25bddad",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exception hierarchy\n",
    "\n",
    "```\n",
    "BaseException\n",
    " ├── BaseExceptionGroup\n",
    " ├── GeneratorExit\n",
    " ├── KeyboardInterrupt\n",
    " ├── SystemExit\n",
    " └── Exception\n",
    "      ├── ArithmeticError\n",
    "      │    ├── FloatingPointError\n",
    "      │    ├── OverflowError\n",
    "      │    └── ZeroDivisionError\n",
    "      ├── AssertionError\n",
    "      ├── AttributeError\n",
    "      ├── BufferError\n",
    "      ├── EOFError\n",
    "      ├── ExceptionGroup [BaseExceptionGroup]\n",
    "      ├── ImportError\n",
    "      │    └── ModuleNotFoundError\n",
    "      ├── LookupError\n",
    "      │    ├── IndexError\n",
    "      │    └── KeyError\n",
    "      ├── MemoryError\n",
    "      ├── NameError\n",
    "      │    └── UnboundLocalError\n",
    "      ├── OSError\n",
    "      │    ├── BlockingIOError\n",
    "      │    ├── ChildProcessError\n",
    "      │    ├── ConnectionError\n",
    "      │    │    ├── BrokenPipeError\n",
    "      │    │    ├── ConnectionAbortedError\n",
    "      │    │    ├── ConnectionRefusedError\n",
    "      │    │    └── ConnectionResetError\n",
    "      │    ├── FileExistsError\n",
    "      │    ├── FileNotFoundError\n",
    "      │    ├── InterruptedError\n",
    "      │    ├── IsADirectoryError\n",
    "      │    ├── NotADirectoryError\n",
    "      │    ├── PermissionError\n",
    "      │    ├── ProcessLookupError\n",
    "      │    └── TimeoutError\n",
    "      ├── ReferenceError\n",
    "      ├── RuntimeError\n",
    "      │    ├── NotImplementedError\n",
    "      │    └── RecursionError\n",
    "      ├── StopAsyncIteration\n",
    "      ├── StopIteration\n",
    "      ├── SyntaxError\n",
    "      │    └── IndentationError\n",
    "      │         └── TabError\n",
    "      ├── SystemError\n",
    "      ├── TypeError\n",
    "      ├── ValueError\n",
    "      │    └── UnicodeError\n",
    "      │         ├── UnicodeDecodeError\n",
    "      │         ├── UnicodeEncodeError\n",
    "      │         └── UnicodeTranslateError\n",
    "      └── Warning\n",
    "           ├── BytesWarning\n",
    "           ├── DeprecationWarning\n",
    "           ├── EncodingWarning\n",
    "           ├── FutureWarning\n",
    "           ├── ImportWarning\n",
    "           ├── PendingDeprecationWarning\n",
    "           ├── ResourceWarning\n",
    "           ├── RuntimeWarning\n",
    "           ├── SyntaxWarning\n",
    "           ├── UnicodeWarning\n",
    "           └── UserWarning\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8882cf82",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## User-defined exceptions\n",
    "\n",
    "Programs have the ability to define their own exceptions by creating custom exception classes. These exception classes should generally inherit from the `Exception` class, either directly or through intermediate subclasses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "585720c7",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class MyCustomError(Exception):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "02058ba1",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "raise MyCustomError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f847c31a",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    raise MyCustomError(\"Custom error message\")\n",
    "except MyCustomError as err:\n",
    "    print(err)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}