python_practice_6.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# I. Docstrings."
      ],
      "metadata": {
        "id": "5qvkYXU42nND"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "1. Що таке docstrings? Навіщо вони потрібні?"
      ],
      "metadata": {
        "id": "7VUggLjZ4NNb"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Це стрічкові літерали (які виділяють потрійними лапками),\n",
        "що використовуються для опису (документації коду). Наприклад, опис мети блоку коду, вказання аргументів для  функції, надання прикладів її використання, вказування типів помилок, що генеруються у функції."
      ],
      "metadata": {
        "id": "_oqTO_30GlHj"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "2. Створіть docstrings для функції, що розраховує суму двох цілих чисел та повертає їхню суму."
      ],
      "metadata": {
        "id": "bRumAhtgG3jV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\"\n",
        "Calculates sum of two integers.\n",
        "\n",
        "Examples:\n",
        "    >>> calculate_sum(1, 2)\n",
        "    3\n",
        "    >>> calculate_sum(-1, 5)\n",
        "    4\n",
        "    >>> calculate_sum(0, 0)\n",
        "    0\n",
        "\n",
        "Parameters:\n",
        "    a (int): first integer for summing.\n",
        "    b (int): fecond integer for summing.\n",
        "\n",
        "Returns:\n",
        "    int. Sum of first integer and second integer.\n",
        "\"\"\""
      ],
      "metadata": {
        "id": "G_xCtwQGGkew",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        },
        "outputId": "5bfbc311-cd93-428b-9f7c-c1bc1aff77a1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'\\nCalculates sum of two integers.\\n\\nExamples:\\n    >>> calculate_sum(1, 2)\\n    3\\n    >>> calculate_sum(-1, 5)\\n    4\\n    >>> calculate_sum(0, 0)\\n    0\\n\\nParameters:\\n    a (int): first integer for summing.\\n    b (int): fecond integer for summing.\\n\\nReturns:\\n    int. Sum of first integer and second integer.\\n'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "3. Визначте функцію, що розраховує суму двох цілих чисел та повертає їхню суму, використовуючи документацію з завдання 2."
      ],
      "metadata": {
        "id": "gibK8CjDHBfc"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {
        "id": "wh5tMJgh0zer",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bd94b2e8-9947-4993-a2aa-c2d087297445"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n"
          ]
        }
      ],
      "source": [
        "def sum(a, b):\n",
        "    \"\"\"\n",
        "    Calculates sum of two integers.\n",
        "\n",
        "    Examples:\n",
        "        >>> calculate_sum(1, 2)\n",
        "        3\n",
        "        >>> calculate_sum(-1, 5)\n",
        "        4\n",
        "        >>> calculate_sum(0, 0)\n",
        "        0\n",
        "\n",
        "    Parameters:\n",
        "        a (int): first integer for summing.\n",
        "        b (int): fecond integer for summing.\n",
        "\n",
        "    Returns:\n",
        "        int. Sum of first integer and second integer.\n",
        "    \"\"\"\n",
        "    return a + b\n",
        "\n",
        "\n",
        "print(sum(1, 2))"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "4. Створіть docstring для функції, що перевіряє, чи є число простим. Увага: під час виклику функції ми очікуємо, що користувач(ка) може подати на вхід будь-який тип обʼєкту. У випадку, якщо на вході не підходящий тип даних, маємо кинути помилку."
      ],
      "metadata": {
        "id": "PI-mNDQNIDUm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\"\n",
        "Checks whether number is prime\n",
        "\n",
        "Examples:\n",
        "    >>> is_prime(2)\n",
        "    True\n",
        "    >>> is_prime(12)\n",
        "    False\n",
        "    >>> is_prime(0)\n",
        "    ValueError                                Traceback (most recent call last)\n",
        "    [output omitted]\n",
        "    ValueError: Integer must be >= 1.\n",
        "    >>> is_prime('abc')\n",
        "    TypeError                                Traceback (most recent call last)\n",
        "    [output omitted]\n",
        "    TypeError: Object passed as argument must be an integer.\n",
        "\n",
        "Args:\n",
        "    n (int): Number to check for being prime\n",
        "\n",
        "Returns:\n",
        "    bool. True, if number is prime, False otherwise.\n",
        "\n",
        "Raises:\n",
        "    TypeError: If argument isn't int type.\n",
        "    ValueError: If number given is < 1.\n",
        "\"\"\""
      ],
      "metadata": {
        "id": "3nTbEkJ0I4Gn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "5. Визначте функцію, яка перевіряє, чи є число простим, використовуючи документацію з завдання 4."
      ],
      "metadata": {
        "id": "OMRx9emvI4NM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def is_prime(n):\n",
        "    \"\"\"\n",
        "    Checks whether number is prime\n",
        "\n",
        "    Examples:\n",
        "        >>> is_prime(2)\n",
        "        True\n",
        "        >>> is_prime(12)\n",
        "        False\n",
        "        >>> is_prime(0)\n",
        "        ValueError                                Traceback (most recent call last)\n",
        "        [output omitted]\n",
        "        ValueError: Integer must be >= 1.\n",
        "        >>> is_prime('abc')\n",
        "        TypeError                                Traceback (most recent call last)\n",
        "        [output omitted]\n",
        "        TypeError: Object passed as argument must be an integer.\n",
        "\n",
        "    Args:\n",
        "        n (int): Number to check for being prime (int >= 1 is expected)\n",
        "\n",
        "    Returns:\n",
        "        bool. True, if number is prime, False otherwise.\n",
        "\n",
        "    Raises:\n",
        "        TypeError: If argument isn't int type.\n",
        "        ValueError: If number given is < 1.\n",
        "    \"\"\"\n",
        "    if not isinstance(n, int):\n",
        "        raise TypeError(\"Object passed as argument must be an integer.\")\n",
        "    if n < 1:\n",
        "        raise ValueError(\"Integer must be >= 1.\")\n",
        "    if n == 1:\n",
        "        return False\n",
        "\n",
        "    for i in range(2, int(n ** 0.5) + 1):\n",
        "        if n % i == 0:\n",
        "            return False\n",
        "    return True\n",
        "\n",
        "print(is_prime(43))"
      ],
      "metadata": {
        "id": "wONHC4OEJARD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1a3ad50f-3116-4ea8-e456-6097064c58ee"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "6. Створіть docstring для функції, що повертає найдовший спільний префікс двох рядків не залежно від регістру. Обовʼязково включіть два приклади згідно формату."
      ],
      "metadata": {
        "id": "1r9WQ5Y9JULV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\"\n",
        "Returns longest common prefix for two strings\n",
        "\n",
        "Examples:\n",
        "    >>> longest_common_prefix(\"Hello\", \"Hi\")\n",
        "    'H'\n",
        "    >>> longest_common_prefix(\"english\", \"england\")\n",
        "    'engl'\n",
        "    >>> longest_common_prefix(\"eNglish\", \"EnGLand\")\n",
        "    'engl'\n",
        "\n",
        "Args:\n",
        "    str1 (str): first string\n",
        "    str2 (str): second string\n",
        "\n",
        "Returns:\n",
        "    str. Longest common prefix for two strings.\n",
        "\"\"\""
      ],
      "metadata": {
        "id": "mqTHuBGsKY2V",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        },
        "outputId": "59f7ccdd-ec50-4353-9c8c-bd84fcf7fe63"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'\\nReturns longest common prefix for two strings\\n\\nExamples:\\n    >>> longest_common_prefix(\"Hello\", \"Hi\")\\n    \\'H\\'\\n    >>> longest_common_prefix(\"english\", \"england\")\\n    \\'engl\\'\\n    >>> longest_common_prefix(\"eNglish\", \"EnGLand\")\\n    \\'engl\\'\\n\\nArgs:\\n    str1 (str): first string\\n    str2 (str): second string\\n\\nReturns:\\n    str. Longest common prefix for two strings.\\n'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "7. Реалізуйте функцію згідно документації із завдання 6, використовуючи її."
      ],
      "metadata": {
        "id": "ZVkQ4jo2KZrx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def longest_common_prefix(str_a, str_b):\n",
        "    \"\"\"\n",
        "    Returns longest common prefix for two strings\n",
        "\n",
        "    Examples:\n",
        "        >>> longest_common_prefix(\"Hello\", \"Hi\")\n",
        "        'H'\n",
        "        >>> longest_common_prefix(\"english\", \"england\")\n",
        "        'engl'\n",
        "        >>> longest_common_prefix(\"eNglish\", \"EnGLand\")\n",
        "        'engl'\n",
        "\n",
        "    Args:\n",
        "        str1 (str): first string\n",
        "        str2 (str): second string\n",
        "\n",
        "    Returns:\n",
        "        str. Longest common prefix for two strings.\n",
        "    \"\"\"\n",
        "    str_a_lower = str_a.lower()\n",
        "    str_b_lower = str_b.lower()\n",
        "\n",
        "    minimal_len = min(len(str_a_lower), len(str_b_lower))\n",
        "\n",
        "    prefix = \"\"\n",
        "    for i in range(minimal_len):\n",
        "        if str_a_lower[i] == str_b_lower[i]:\n",
        "            prefix += str_a_lower[i]\n",
        "        else:\n",
        "            break\n",
        "\n",
        "    return prefix\n",
        "\n",
        "\n",
        "print(longest_common_prefix(\"eNglish\", \"EnGLand\"))"
      ],
      "metadata": {
        "id": "e1odBJATKd7L",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2b08b55f-afcd-4b4e-c954-781b6739d839"
      },
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "engl\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "8. Створіть docstring для функції, що розраховує суму щомісячного платежу по єОселі."
      ],
      "metadata": {
        "id": "OXbxPfuZKlQb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\"\n",
        "Calculate the monthly payment for the 'eOselya' program.\n",
        "\n",
        "Note: I use simplified model, where payments are equal.\n",
        "\n",
        "Examples:\n",
        "    >>> calculate_monthly_payment(Decimal(300000), 120)\n",
        "    Decimal(3483.25)\n",
        "\n",
        "    >>> calculate_monthly_payment(Decimal(500000), 60)\n",
        "    Decimal(9900.60)\n",
        "\n",
        "Args:\n",
        "    credit_amount (Decimal): amount of the credit\n",
        "    credit_term (int): credit term in months\n",
        "\n",
        "Returns:\n",
        "    Decimal. The monthly payment for the credit.\n",
        "\n",
        "Raises:\n",
        "    ValueError: If the credit amount is not between 100'000 and 4'000'000 UAH,\n",
        "                or if the credit term is not between 24 and 240 months.\n",
        "\n",
        "\"\"\""
      ],
      "metadata": {
        "id": "iFGckfs3KqHq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "9. Використовуючи документацію із завдання 8, реалізуйте відповідну функцію."
      ],
      "metadata": {
        "id": "xQjsUPhAOUq1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from decimal import Decimal, getcontext, ROUND_HALF_UP\n",
        "\n",
        "\n",
        "def calculate_monthly_payment(credit_amount, credit_term):\n",
        "    \"\"\"\n",
        "    Calculate the monthly payment for the 'eOselya' program.\n",
        "\n",
        "    Note: I use simplified model, where payments are equal.\n",
        "\n",
        "    Examples:\n",
        "        >>> calculate_monthly_payment(Decimal(300000), 120)\n",
        "        Decimal(3483.25)\n",
        "\n",
        "        >>> calculate_monthly_payment(Decimal(500000), 60)\n",
        "        Decimal(9900.60)\n",
        "\n",
        "    Args:\n",
        "        credit_amount (Decimal): amount of the credit\n",
        "        credit_term (int): credit term in months\n",
        "\n",
        "    Returns:\n",
        "        Decimal. The monthly payment for the credit.\n",
        "\n",
        "    Raises:\n",
        "        ValueError: If the credit amount is not between 100'000 and 4'000'000 UAH,\n",
        "                    or if the credit term is not between 24 and 240 months.\n",
        "\n",
        "    \"\"\"\n",
        "    getcontext().rounding = ROUND_HALF_UP\n",
        "\n",
        "    min_credit_amount = Decimal(100000)  # 100'000 UAH\n",
        "    max_credit_amount = Decimal(4000000)  # 4'000'000 UAH\n",
        "    min_loan_term = 24\n",
        "    max_loan_term = 240\n",
        "    min_first_installment_percentage = Decimal(0.20) # 20%\n",
        "\n",
        "    annual_interest_rate = Decimal(0.07)  # 7%\n",
        "\n",
        "    if not (min_credit_amount <= credit_amount <= max_credit_amount):\n",
        "        raise ValueError(\"Credit amount must be from 100'000 up to 4'000'000 UAH\")\n",
        "    if not (min_loan_term <= credit_term <= max_loan_term):\n",
        "        raise ValueError(\"Credit term must be in range from 24 to 240 months\")\n",
        "\n",
        "    monthly_interest_rate = annual_interest_rate / Decimal(12)\n",
        "\n",
        "    monthly_payment = (credit_amount*monthly_interest_rate) / (1 - (1 + monthly_interest_rate)**(-credit_term))\n",
        "\n",
        "    return monthly_payment.quantize(Decimal('0.00'), rounding = ROUND_HALF_UP)\n",
        "\n",
        "\n",
        "\n",
        "print(\"Monthly payment:\", calculate_monthly_payment(Decimal(300000), 120))"
      ],
      "metadata": {
        "id": "H3_FpZW7OUAA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fb5185bf-0661-4b90-ae33-a6829d10ec08"
      },
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Monthly payment: 3483.25\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# II. Errors and exceptions handling."
      ],
      "metadata": {
        "id": "uPyZWU1r2q-s"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "10. Реалізуйте функцію, яка отримує значення зі словника за ключем та повертає його, а за умови відсутності ключа відловлює KeyError."
      ],
      "metadata": {
        "id": "GJAVQ9SJbARP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def value_from_dictionary(dictionary, key):\n",
        "    try:\n",
        "        return dictionary[key]\n",
        "    except KeyError:\n",
        "        print(f\"Key '{key}' not found in the dictionary.\")\n",
        "        return None\n",
        "\n",
        "\n",
        "short_dictionary = {'a': 5, 'b': 3, 'c': 7}\n",
        "\n",
        "value = value_from_dictionary(short_dictionary, 'a')\n",
        "print(\"Value found:\", value)"
      ],
      "metadata": {
        "id": "01YDTgxI4IK7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ce505cd5-b5e7-49ed-8a13-ce61ee0589e4"
      },
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Value found: 5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "11. Реалізуйте функцію із завдання 10 без відловлювання помилки, однак за допомогою конструкції if-else."
      ],
      "metadata": {
        "id": "IwpB9_4Jbttd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def get_value_from_dict(dictionary, key):\n",
        "    if key in dictionary:\n",
        "        return dictionary[key]\n",
        "    else:\n",
        "        print(f\"Key '{key}' not found in the dictionary.\")\n",
        "        return None\n",
        "\n",
        "\n",
        "value = get_value_from_dict(short_dictionary, 'a')\n",
        "print(\"Value found:\", value)"
      ],
      "metadata": {
        "id": "qSEr1bCQbtC1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1e599674-c68d-47c9-bbf7-b192e98a5f82"
      },
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Value found: 5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "12. Реалізуйте функцію з завдання 10, використовуючи метод словника, який дозволяє зробити операцію навіть без if-else."
      ],
      "metadata": {
        "id": "H4iygP7xb7xB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def get_value_from_dict_method(dictionary, key):\n",
        "    return dictionary.get(key, None)\n",
        "\n",
        "\n",
        "value = get_value_from_dict_method(short_dictionary, 'd')\n",
        "print(\"Value found:\", value)"
      ],
      "metadata": {
        "id": "IjFPCfCXcFMF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8a21c5eb-6c3a-4de0-b1fa-e85b657a2120"
      },
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Value found: None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "13. Визначте функцію, яка обробляє значення, введене користувачем з терміналу, приводячи його до цілого числа. Використайте відловлення відповідної помилки. Наприклад, людина має ввести свій вік."
      ],
      "metadata": {
        "id": "V7UB77SvcFiH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def get_integer_input(prompt='Enter integer: '):\n",
        "    try:\n",
        "        user_input = input(prompt)\n",
        "        integer_value = int(user_input)\n",
        "        return integer_value\n",
        "    except ValueError:\n",
        "        print(\"Not an integer entered.\")\n",
        "        return None\n",
        "\n",
        "\n",
        "print(get_integer_input())"
      ],
      "metadata": {
        "id": "OEkZInsUce-g",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fe0fa2d9-cdf9-412c-cf05-32e481c6701f"
      },
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter integer: 18\n",
            "18\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "14. Визначте функцію з завдання 13, де використайте конструкцію if-else замість відловдення помилки."
      ],
      "metadata": {
        "id": "nvQo1fzjcfYI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def get_integer_input_if_else(prompt='Enter integer: '):\n",
        "    user_input = input(prompt)\n",
        "    if user_input.isdigit():\n",
        "        return int(user_input)\n",
        "    else:\n",
        "        print(\"Not an integer entered.\")\n",
        "        return None\n",
        "\n",
        "\n",
        "print(get_integer_input_if_else())"
      ],
      "metadata": {
        "id": "bQF8LazacpUI",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6c1ab036-25e8-4976-883c-e96ba40f3386"
      },
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter integer: 18\n",
            "18\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "15. Визначте функцію з завдання 13, враховуючи додаткове обмеження, що число має бути у діапазоні від 18 до 120 (повнолітня людина). Відловіть відповідні типи помилок."
      ],
      "metadata": {
        "id": "l4RoecD_dIj5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def get_integer_input_in_range(prompt='Enter integer: '):\n",
        "    try:\n",
        "        user_input = input(prompt)\n",
        "        integer_value = int(user_input)\n",
        "        if 18 <= integer_value <= 120:\n",
        "            return integer_value\n",
        "        else:\n",
        "            raise ValueError(\"ValueError: age is not between 18 and 120 including.\")\n",
        "    except ValueError as e:\n",
        "        print(e)\n",
        "        return None\n",
        "\n",
        "\n",
        "print(get_integer_input_in_range())"
      ],
      "metadata": {
        "id": "SeHKtFGTdiyD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "da493b10-4fe9-40ca-f822-1d80c62bac05"
      },
      "execution_count": 50,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter integer: 1\n",
            "ValueError: age is not between 18 and 120 including.\n",
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "16. Напишіть код, який би генерував максимальну кількість помилок різного типу."
      ],
      "metadata": {
        "id": "MAn64KyreVC4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def generate_errors():\n",
        "    result = 1 / 0\n",
        "\n",
        "    my_list = [\"asd\", 0, 3.3]\n",
        "    print(my_list[4])\n",
        "\n",
        "    int(\"asdfasvcs\")\n",
        "\n",
        "    unreal_function()\n",
        "\n",
        "    \"hello\".next()\n",
        "\n",
        "    my_dict = {'one': 1, 'two': 2}\n",
        "    print(my_dict['three'])\n",
        "\n",
        "    \"123\" + 10\n",
        "\n",
        "\n",
        "generate_errors()"
      ],
      "metadata": {
        "id": "DzuV3uQpeb-U",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 297
        },
        "outputId": "f0d2febb-fe96-4630-da14-9fc38566a217"
      },
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "error",
          "ename": "ZeroDivisionError",
          "evalue": "division by zero",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-51-bd0ac65c1369>\u001b[0m in \u001b[0;36m<cell line: 19>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     17\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     18\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 19\u001b[0;31m \u001b[0mgenerate_errors\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m<ipython-input-51-bd0ac65c1369>\u001b[0m in \u001b[0;36mgenerate_errors\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mgenerate_errors\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0mmy_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m\"asd\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3.3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmy_list\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "17. Наскільки це можливо, виправте код із завдання 16."
      ],
      "metadata": {
        "id": "5VFbEKQkecMz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def generate_errors_catch():\n",
        "    try:\n",
        "        result = 1 / 0\n",
        "    except ZeroDivisionError:\n",
        "        print(\"ZeroDivisionError caught\")\n",
        "\n",
        "    try:\n",
        "        my_list = [\"asd\", 0, 3.3]\n",
        "        print(my_list[4])\n",
        "    except IndexError:\n",
        "        print(\"IndexError caught\")\n",
        "\n",
        "    try:\n",
        "        int(\"asdfasvcs\")\n",
        "    except ValueError:\n",
        "        print(\"ValueError caught\")\n",
        "\n",
        "    try:\n",
        "        unreal_function()\n",
        "    except NameError:\n",
        "        print(\"NameError caught\")\n",
        "\n",
        "    try:\n",
        "        \"hello\".next()\n",
        "    except AttributeError:\n",
        "        print(\"AttributeError caught\")\n",
        "\n",
        "    try:\n",
        "        my_dict = {'one': 1, 'two': 2}\n",
        "        print(my_dict['three'])\n",
        "    except KeyError:\n",
        "        print(\"KeyError caught\")\n",
        "\n",
        "    try:\n",
        "        \"123\" + 10\n",
        "    except TypeError:\n",
        "        print(\"TypeError caught\")\n",
        "\n",
        "\n",
        "generate_errors_catch()"
      ],
      "metadata": {
        "id": "peMOBz9ieiur",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0c2004a3-3476-4ed7-af33-a5c6df08f545"
      },
      "execution_count": 52,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "ZeroDivisionError caught\n",
            "IndexError caught\n",
            "ValueError caught\n",
            "NameError caught\n",
            "AttributeError caught\n",
            "KeyError caught\n",
            "TypeError caught\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Вітаю! Ви велика(ий) молодець, що впоралась(вся). Похваліть себе та побалуйте чимось приємним. Я Вами пишаюся."
      ],
      "metadata": {
        "id": "503e6tDw20ZG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![image.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "LkE54eNm3_8H"
      }
    }
  ]
}