error-handling.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "decent-profit",
   "metadata": {},
   "source": [
    "# Error handling\n",
    "\n",
    "Errors are an inevitable part of programming. Whether you're a beginner or an experienced developer, you will encounter errors in your code. Python provides a robust mechanism for dealing with these errors, known as \"error handling\" or \"exception handling.\"\n",
    "\n",
    "In this notebook, we'll explore the world of error handling in Python. We'll learn about different types of errors, how to detect and handle them gracefully, and best practices for writing reliable and robust code.\n",
    "\n",
    "By the end of this notebook, you'll have a solid understanding of:\n",
    "\n",
    "- Common types of errors in Python.\n",
    "- How to use try-except blocks to catch and handle exceptions.\n",
    "- The role of the else and finally clauses in exception handling.\n",
    "- Customizing error messages and creating custom exceptions.\n",
    "- Best practices for writing error-resistant code.\n",
    "\n",
    "Whether you're building small scripts or large applications, mastering error handling is a crucial skill that will help you write more reliable and maintainable Python code.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "passive-electricity",
   "metadata": {},
   "source": [
    "![elgif](https://media.giphy.com/media/WhFfFPCEDXpBe/giphy.gif)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "positive-length",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h3>Table of Contents<span class=\"tocSkip\"></span></h3>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Introduction\" data-toc-modified-id=\"Introduction-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Introduction</a></span></li><li><span><a href=\"#Syntax-Errors\" data-toc-modified-id=\"Syntax-Errors-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Syntax Errors</a></span></li><li><span><a href=\"#Exceptions-/-Errors\" data-toc-modified-id=\"Exceptions-/-Errors-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Exceptions / Errors</a></span><ul class=\"toc-item\"><li><span><a href=\"#LookupError\" data-toc-modified-id=\"LookupError-3.1\"><span class=\"toc-item-num\">3.1&nbsp;&nbsp;</span>LookupError</a></span><ul class=\"toc-item\"><li><span><a href=\"#KeyError\" data-toc-modified-id=\"KeyError-3.1.1\"><span class=\"toc-item-num\">3.1.1&nbsp;&nbsp;</span>KeyError</a></span></li><li><span><a href=\"#IndexError\" data-toc-modified-id=\"IndexError-3.1.2\"><span class=\"toc-item-num\">3.1.2&nbsp;&nbsp;</span>IndexError</a></span></li></ul></li><li><span><a href=\"#ImportError\" data-toc-modified-id=\"ImportError-3.2\"><span class=\"toc-item-num\">3.2&nbsp;&nbsp;</span>ImportError</a></span></li><li><span><a href=\"#AttributeError\" data-toc-modified-id=\"AttributeError-3.3\"><span class=\"toc-item-num\">3.3&nbsp;&nbsp;</span>AttributeError</a></span></li><li><span><a href=\"#ValueError\" data-toc-modified-id=\"ValueError-3.4\"><span class=\"toc-item-num\">3.4&nbsp;&nbsp;</span>ValueError</a></span></li><li><span><a href=\"#TypeError\" data-toc-modified-id=\"TypeError-3.5\"><span class=\"toc-item-num\">3.5&nbsp;&nbsp;</span>TypeError</a></span></li><li><span><a href=\"#OSError\" data-toc-modified-id=\"OSError-3.6\"><span class=\"toc-item-num\">3.6&nbsp;&nbsp;</span>OSError</a></span><ul class=\"toc-item\"><li><span><a href=\"#FileNotFoundError\" data-toc-modified-id=\"FileNotFoundError-3.6.1\"><span class=\"toc-item-num\">3.6.1&nbsp;&nbsp;</span>FileNotFoundError</a></span></li></ul></li><li><span><a href=\"#TimeOutError\" data-toc-modified-id=\"TimeOutError-3.7\"><span class=\"toc-item-num\">3.7&nbsp;&nbsp;</span>TimeOutError</a></span></li></ul></li><li><span><a href=\"#Exception-handling\" data-toc-modified-id=\"Exception-handling-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Exception handling</a></span><ul class=\"toc-item\"><li><span><a href=\"#What-not-to-do-when-handling-exceptions\" data-toc-modified-id=\"What-not-to-do-when-handling-exceptions-4.1\"><span class=\"toc-item-num\">4.1&nbsp;&nbsp;</span>What not to do when handling exceptions</a></span></li></ul></li><li><span><a href=\"#Data-validation-with-assert\" data-toc-modified-id=\"Data-validation-with-assert-5\"><span class=\"toc-item-num\">5&nbsp;&nbsp;</span>Data validation with <code>assert</code></a></span></li><li><span><a href=\"#Raise-errors\" data-toc-modified-id=\"Raise-errors-6\"><span class=\"toc-item-num\">6&nbsp;&nbsp;</span>Raise errors</a></span></li><li><span><a href=\"#Summary\" data-toc-modified-id=\"Summary-7\"><span class=\"toc-item-num\">7&nbsp;&nbsp;</span>Summary</a></span></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a0e59df",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "## Introduction\n",
    "\n",
    "In the world of programming, errors are a common occurrence. Even a tiny mistake, like a missing semicolon or a typo, can lead to unexpected issues in your code. In Python, these errors fall into two broad categories: syntax errors and runtime errors.\n",
    "\n",
    "**Syntax errors** occur when your code violates the rules of the Python language. These are usually straightforward to identify because Python will point you directly to the problematic line of code. For example, writing `while True print(\"Hello world\")` is a syntax error because the colon after `True` is missing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f9b79396",
   "metadata": {},
   "outputs": [],
   "source": [
    "while True print(\"Hello world\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab975d62",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "**Runtime errors**, on the other hand, are trickier to catch. They occur while your program is running and typically stem from logical issues or unexpected inputs. For instance, dividing by zero, accessing an undefined variable, or trying to open a non-existent file can result in runtime errors. Unlike syntax errors, runtime errors may not always crash your program immediately, making them more challenging to diagnose.\n",
    "\n",
    "Error handling is a crucial skill for any programmer. Knowing how to detect, prevent, and gracefully handle errors can significantly improve the reliability and robustness of your code. Python provides powerful mechanisms to manage errors, and in this notebook, we will delve into various error-handling techniques.\n",
    "\n",
    "As we explore the world of error handling, remember that handling errors is not about eliminating them entirely but rather about responding to them effectively. Let's dive in and become skilled error handlers in Python!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "787b2a46",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "## Syntax Errors\n",
    "\n",
    "Syntax errors, often referred to as syntax or Python interpreter errors, are a common stumbling block when learning a new programming language, especially for those transitioning from other languages. These errors typically occur due to unfamiliarity with or oversight of Python's lexical rules, and they are detected by the interpreter before your program can even run. In essence, syntax errors represent poorly formed expressions that violate the language's fundamental rules.\n",
    "\n",
    "In contrast to compiled languages like C, which perform code analysis to produce an executable file (catching errors before runtime), interpreted languages like Python lack this pre-execution phase. This means that Python interpreters accept our code with an inherent uncertainty about its correctness. However, the interpreter diligently scrutinizes your code as soon as it's read, well before executing any instructions.\n",
    "\n",
    "When Python encounters a syntax error, it processes your code line by line, and as soon as it detects a syntax violation, it promptly halts and points out the error's location. For instance, consider the following example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1cd85e49",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. Reading / parses \n",
    "    # typos, syntax: colons, tabulation, etc\n",
    "    \n",
    "# 2. Execute the code\n",
    "    # content of the code\n",
    "    # variables have meaning: they are read"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ce4c5e01",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = \"My name is something'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ab749d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. Syntax\n",
    "    # We need to correct the wrong syntax\n",
    "\n",
    "# 2. Logic\n",
    "    # prevent error from happening if they are due to logic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "84e84a65",
   "metadata": {},
   "outputs": [],
   "source": [
    "10/0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3ed74348",
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    10 ////// 0\n",
    "except:\n",
    "    print(\"hello\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a8f419f",
   "metadata": {},
   "source": [
    "`Fixing syntax errors`: "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a34bf0a",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "It is very helpful it'll indicate the place where it detected the error and, in addition, it does provide us with information about it. In this case it is indicating that the syntax from the print is not correct, so that we realize that we are making a mistake by not putting the colon after the True.\n",
    "In a syntax error message we distinguish two parts:\n",
    "- The path of the error: In the previous example, all the lines except the last one.\n",
    "- The description of the error: in the example above, the last line.\n",
    "\n",
    "Syntax errors are usually easy to fix, but sometimes an error that is triggered at one point can come from another point and that error path (or traceback) goes in descending order from the point at which the error was triggered, passing through various intermediate points (if any) to the point where the error occurred. In practice, this means that if we do not find anything on the line where the error is indicated, we will have to review the previous instructions until we find it."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5e4b906",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "## Exceptions / Errors \n",
    "An exception is a logical error that occurs at run time. In this case, the syntax of the instructions is correct and, for this reason, the Python interpreter will not stop or show any error when launching the program, but at the moment of execution it will stop and show an error, this is what is called a \"runtime error\".\n",
    "Exceptions are associated with different types, and that same type is the one that is shown in the error message. In addition to this information, details indicating the cause of the error are also displayed. All this will allow you to have enough information to find the fault and solve or manage it.\n",
    "Some examples of exceptions are as follows:\n",
    "- ZeroDivisionError: division by zero\n",
    "- NameError: name 'dflhjka' is not defined\n",
    "- TypeError: can only concatenate str (not \"int\") to str\n",
    "\n",
    "Python has a number of predefined exceptions, divided into base exceptions and concrete exceptions. The base exceptions are more generic and group the different types more specifically, which will allow you to make a more general treatment in your programs. On the contrary, the concrete exceptions offer more detail of the error produced.\n",
    "\n",
    "🚨⚠️Documentation [HERE](https://docs.python.org/3/library/exceptions.html)⚠️🚨\n",
    "\n",
    "Let's see some:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49616421",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "### LookupError\n",
    "This is the base class for exceptions that are raised when a key or index used in an assignment or sequence is invalid: IndexError, KeyError.\n",
    "#### KeyError\n",
    "Fired when a mapping key (dictionary) is not found in the set of existing keys."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d82ff0c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "dict_ = {\"name\": \"Albert\",\n",
    "        \"age\": 30}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c8fd746a",
   "metadata": {},
   "outputs": [],
   "source": [
    "dict_[\"city\"] = \"Mataró\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ff3eb2b",
   "metadata": {},
   "outputs": [],
   "source": [
    "dict_[\"city\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "33616433",
   "metadata": {},
   "outputs": [],
   "source": [
    "dict_[\"role\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51499c48",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "#### IndexError\n",
    "Thrown when a subscript in the sequence is out of range."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6b13989b",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst_ = [1, 2, 3, 54]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "86e7280a",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst_[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "05a7952c",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst_[5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "77ef4a08",
   "metadata": {},
   "outputs": [],
   "source": [
    "# if you're looping through something through the index: range(1, 11)\n",
    "#len(range(iterable)) last element + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bdb79aec",
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [1, 2, 3, 4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24901352",
   "metadata": {},
   "outputs": [],
   "source": [
    "new_list = []\n",
    "\n",
    "\n",
    "for i in range(7):\n",
    "    new_list.append(numbers[i]**2)\n",
    "                    #numbers[0] #position 0\n",
    "                    #numbers[4] # Error message\n",
    "    print(numbers[i]**2)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be0e47c1",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "### ImportError\n",
    "Occurs when there are problems loading a module or when it is not found. is the base class of the `ModuleNotFoundError` exception"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "46a9b610",
   "metadata": {},
   "outputs": [],
   "source": [
    "import maz #mispelt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c327fd3d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import selenium # INSTALLED but different environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d0eb718d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import selenium #not installed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0be8bbe1",
   "metadata": {},
   "outputs": [],
   "source": [
    "from vikingClasses import Soldier #path is wrong"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ee3177f",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "### AttributeError\n",
    "Thrown when a reference to an attribute or assignment fails."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "97973d68",
   "metadata": {},
   "outputs": [],
   "source": [
    "num = 20"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6866b2f",
   "metadata": {},
   "source": [
    "```python\n",
    "# bad example, don't do at home\n",
    "class Int (Object):\n",
    "    def __init__ (self):\n",
    "        pass\n",
    "    \n",
    "    def metodo (self):\n",
    "        pass\n",
    "    \n",
    "    #def upper():\n",
    "        #pass\n",
    "    \n",
    "num = Int(20)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8fbea814",
   "metadata": {},
   "outputs": [],
   "source": [
    "num.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2fd04934",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Using a mehtod to an object that is different than you think"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0eafd9c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "nested_lists = [[[1, 2, 3]]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4a9e415a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# include prints\n",
    "   # if you do loops "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a6a7a24",
   "metadata": {},
   "outputs": [],
   "source": [
    "flat_list = [k for i in nested_lists for x in i for num in x for k in num] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e1650e29",
   "metadata": {},
   "outputs": [],
   "source": [
    "flat_list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9fd663c8",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "### ValueError\n",
    "Thrown when a function receives an argument of a correct type, but with an incorrect value.\n",
    "Passing arguments of the wrong type (for example, passing a list when an int is expected) should result in a TypeError, but passing arguments with the wrong value (for example, a number outside the expected bounds) should result in a ValueError."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5940d1eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "variable = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "262c6c22",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst_ =  [1, 2, 3, 4, 5 ,6 ,7, 8, 9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8cf163af",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst_.remove(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1744af1f",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst_.remove(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d3d3ca76",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5fbf98e",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "### TypeError\n",
    "Occurs when an operation or function is applied to an object of the wrong type. The associated value is a string giving details about the type mismatch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f9cb8e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"This is a string\" + \"something else\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "98c0267a",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"This is a string\" * \"something else\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "95a16dd7",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Hello\" * 2 #HelloHello ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "20e8a27f",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Hello\" * 2.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0cd14399",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Hello\" * int(2.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3d4a926f",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Hello\" + \"2\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "15bf6566",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Hello\" + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "73c92eea",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"string\" * int(2.9)\n",
    "\n",
    "# Error\n",
    "# result: 2 (truncates) ?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94f5f2bf",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "### OSError\n",
    "Occurs when a system-related error occurs, such as an input/output operation failure, files not found, etc. It is the base class and the exceptions that we will see the most are:\n"
   ]
  },
  {
   "attachments": {
    "OSError.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "9bf73372",
   "metadata": {},
   "source": [
    "![OSError.png](attachment:OSError.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "678f4a80",
   "metadata": {},
   "source": [
    "#### FileNotFoundError\n",
    "File or directory does not exist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cb923755",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9b29189f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Find the actual path to this file: \"avocado_kaggle.csv\"\n",
    "\n",
    "# bash: grep/find"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8f7eb059",
   "metadata": {},
   "outputs": [],
   "source": [
    "!code ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e913990a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os \n",
    "\n",
    "bash_command = \"\"\"\n",
    "ls;\n",
    "open .;\n",
    "\"\"\"\n",
    "os.system(bash_command)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71b975d1",
   "metadata": {},
   "outputs": [],
   "source": [
    "!ls ../datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "44a6e696",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"../\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ca7332cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"../datasets/avocado_kaggle.csv\")\n",
    "df.sample()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ccef662",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"../datasets/avocado_kaggle.csv\") #relative to this notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aea38c90",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"/Users/fernandocosta/IRONHACK/ft/lectures/datasets/avocado_kaggle.csv\") #?\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "611249ca",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "### TimeOutError\n",
    "Occurs when the waiting time is exceeded (we will see it in Katas and API calls, we will not handle it as such)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ab9bb799",
   "metadata": {},
   "outputs": [],
   "source": [
    "def addition (x):\n",
    "    num = 1\n",
    "    while num > 0:\n",
    "        return addition(num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "10af8805",
   "metadata": {},
   "outputs": [],
   "source": [
    "addition(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59da9f19",
   "metadata": {},
   "outputs": [],
   "source": [
    "# tests\n",
    "# servers\n",
    "    # timeout error"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb685743",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "## Exception handling\n",
    "Exception handling is a programming technique to control errors that occur during the execution of an application. They are handled in a similar way to a conditional statement. If an exception (General or specific) does not occur, which would be the normal case, the application continues with the following instructions and, if one occurs, the instructions indicated by the developer for its treatment will be executed, which can continue the application or stop it, depending on the case. Exception handling in Python starts with a keyword structure, like this:\n",
    "```python\n",
    "try:\n",
    "    instructions\n",
    "except:\n",
    "    instructions if that exception occurs\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f8cb236",
   "metadata": {},
   "outputs": [],
   "source": [
    "# errros: give us info\n",
    "# they stop the code\n",
    "    # didnt anticipate the issue\n",
    "    # we did anticipate: keep things running"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "289d32a8",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "In this exception management, the type of the exception can be generic or specific. The best way to control and handle what happened is to do it as specifically as possible, by writing multiple except clauses for the same try, each handling a different type of exception. This is recommended because in this way we will make a more precise management of the detected error cases.\n",
    "```python\n",
    "try:\n",
    "    instructions\n",
    "    except exception type 1:\n",
    "        instructions if that exception occurs 1\n",
    "    except exception type 2:\n",
    "        instructions if that exception occurs\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "afbde5ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    pass\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "92baf839",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst_ = [1, 2, 3, 4, 5, \"6\", 7, 8, 9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ce533647",
   "metadata": {},
   "outputs": [],
   "source": [
    "[i**2 for i in lst_]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a93ba23",
   "metadata": {},
   "outputs": [],
   "source": [
    "squared_list = []\n",
    "\n",
    "for i in lst_:\n",
    "    squared_list.append(i**2)\n",
    "\n",
    "squared_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "559fedcd",
   "metadata": {},
   "outputs": [],
   "source": [
    "squared_list = []\n",
    "\n",
    "for i in lst_:\n",
    "    try:\n",
    "        squared_list.append(i**2)\n",
    "    except:\n",
    "        print(f\"The element {i} cannot be squared, it is of type {type(i)}\")\n",
    "\n",
    "squared_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3d6b7b8f",
   "metadata": {},
   "outputs": [],
   "source": [
    "squared_list = []\n",
    "exceptions_list = []\n",
    "\n",
    "for i in lst_:\n",
    "    try:\n",
    "        squared_list.append(i**2)\n",
    "    except:\n",
    "        exceptions_list.append(i)\n",
    "        print(f\"The element {i} cannot be squared, it is of type {type(i)}\")\n",
    "\n",
    "squared_list\n",
    "exceptions_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1bbc44b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def elements_powered (lst_):\n",
    "    squared_list = []\n",
    "    exceptions_list = []\n",
    "\n",
    "    for i in lst_:\n",
    "        try:\n",
    "            squared_list.append(i**2)\n",
    "        except:\n",
    "            exceptions_list.append(i)\n",
    "            print(f\"The element {i} cannot be squared, it is of type {type(i)}\")\n",
    "\n",
    "    return squared_list, exceptions_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d5d36ce1",
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b = (10, 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "25bcb423",
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78b58853",
   "metadata": {},
   "outputs": [],
   "source": [
    "b "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6a06fb16",
   "metadata": {},
   "outputs": [],
   "source": [
    "elements_powered ([1, 2, 3, 4, 5, \"6\", 7, 8, 9, \"10\", [0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8dd8e400",
   "metadata": {},
   "outputs": [],
   "source": [
    "powered, exceptions = elements_powered ([1, 2, 3, 4, 5, \"6\", 7, 8, 9, \"10\", [0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5790eddb",
   "metadata": {},
   "outputs": [],
   "source": [
    "powered"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ef2a32eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "exceptions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f98b0eef",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "### What not to do when handling exceptions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b3f1a0f",
   "metadata": {},
   "source": [
    "⚠️: TO AVOID"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "02fc35fb",
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    #\n",
    "    #\n",
    "    #\n",
    "    #\n",
    "    #\n",
    "    pass\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "18e65614",
   "metadata": {},
   "outputs": [],
   "source": [
    "try: #IF this works: do this\n",
    "    \n",
    "except: #ELIF it doesn't: do this\n",
    "\n",
    "except:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5bdc321f",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst_ = [1, 2, 3, 4, 5, \"a string\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "05a9d8d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "new_list = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8ff86b83",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst_[1] ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "91485543",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(20):\n",
    "    try:\n",
    "        new_list.append(lst_[i]**2)\n",
    "    except IndexError: \n",
    "        print(f\"The length is less than {i} \")\n",
    "    except TypeError:\n",
    "        print(f\"The type of {i} is {type(i)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c8a236f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "def squaring_numbers (lst_):\n",
    "    new_list = []\n",
    "    \n",
    "    for i in range(20):\n",
    "        try:\n",
    "            new_list.append(lst_[i]**2)\n",
    "        except IndexError: \n",
    "            print(f\"The length is less than {i} \")\n",
    "        except TypeError as ERRORSITO:\n",
    "            print(f\"The type of {i} is {type(i)}: errorsito {ERRORSITO}\")\n",
    "    \n",
    "    return new_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "069ab550",
   "metadata": {},
   "outputs": [],
   "source": [
    "squaring_numbers (lst_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d499fb8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Test driven development\n",
    "    # 1. First write the test\n",
    "    # 2. Write the code\n",
    "    # 3. You make the code pass your test (that you did before)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b5badee",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "## Data validation with `assert`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d629a7b9",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "Python provides a way to set enforceable conditions, that is, conditions that an object must meet or else an exception will be thrown. It is like a kind of \"safety net\" against possible failures of the programmer. The `assert` statement adds controls for debugging a program. It allows us to express a condition that must always be true, and that, if not, will interrupt the program, generating an exception to handle called AssertionError. The way to call this expression is as follows:\n",
    "```python\n",
    "assert boolean condition\n",
    "```\n",
    "In case the boolean expression is true, assert does nothing. If it is false, it throws an exception. Let's see an example to understand it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ae46bb62",
   "metadata": {},
   "outputs": [],
   "source": [
    "#AssertionError: 250 != 300"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b19c2c5a",
   "metadata": {},
   "outputs": [],
   "source": [
    "assert #MAKE SURE THIS IS THIS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9502aa96",
   "metadata": {},
   "outputs": [],
   "source": [
    "assert 10 == 10, \"sdsd\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d808ef7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "assert 10 == 11, \"Not equal\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f733af06",
   "metadata": {},
   "outputs": [],
   "source": [
    "assert 10 == 11, \"Harold didnt die :)\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85fa8694",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "## Raise errors\n",
    "We write a function that multiplies a number by 2 as long as the input argument is an integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "28288436",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Syntax errors\n",
    "# Erros / exceptions\n",
    "\n",
    "# I want the code to continue running even if I find an error  -> try/except\n",
    "# I want to stop the code EVEN if there's no errors\n",
    "   # stop the execution of code:\n",
    "    # assert\n",
    "    # raiseExceptions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41d8c8f4",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "We ask the user to enter the character c to continue or the character f to end. However, we cannot guarantee that you will always enter any of these characters. Therefore, we create our own exception, which we call MyException. In this way, if the user enters a character other than c and f, the created exception will be thrown and an error message will be displayed indicating that the character entered is not valid."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d72d52c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def multiply_by_2 (x):\n",
    "    return x*2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0ca306e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "multiply_by_2(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa7b073f",
   "metadata": {},
   "outputs": [],
   "source": [
    "multiply_by_2(\"10\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70cfe7ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "def multiply_by_2 (x):\n",
    "    if type(x) == int:\n",
    "        return x*2\n",
    "    else:\n",
    "        raise ValueError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "827df70f",
   "metadata": {},
   "outputs": [],
   "source": [
    "multiply_by_2 (10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e8e1d513",
   "metadata": {},
   "outputs": [],
   "source": [
    "multiply_by_2 (\"10\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e02e761d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def multiply_by_2 (x):\n",
    "    if type(x) == int:\n",
    "        return x*2\n",
    "    elif type(x) == str:\n",
    "        try:\n",
    "            return int(x) * 2\n",
    "        except:\n",
    "            raise ValueError\n",
    "    else:\n",
    "        print(\"Hello! I'm within the else\")\n",
    "        raise ValueError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a79a8c3a",
   "metadata": {},
   "outputs": [],
   "source": [
    "multiply_by_2 (10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96392563",
   "metadata": {},
   "outputs": [],
   "source": [
    "multiply_by_2 (\"10\") # elif: str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "04c8b112",
   "metadata": {},
   "outputs": [],
   "source": [
    "multiply_by_2 ([10]) #else"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b938acd",
   "metadata": {},
   "source": [
    "Using except Exception will allow us to later on check for the type it was:\n",
    "\n",
    "\n",
    "```python\n",
    "except Exception as variable_saved:\n",
    "    # TypeError\n",
    "    print(type(variable_saved)) #-> It was indeed a TypeError\n",
    "\n",
    "    \n",
    "except: # on it's own, not a lot of info\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4f7feb75",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyCoolException(Exception):\n",
    "    def __init__ (self, string):\n",
    "        self.value = string\n",
    "        \n",
    "    def __str__ (self):\n",
    "        return f\"There was an error here: {self.value}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "27dda4e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def multiply_by_2 (x):\n",
    "    if type(x) == int:\n",
    "        return x*2\n",
    "    else:\n",
    "        raise MyCoolException(\"errorsito\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bb2f69f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "multiply_by_2 (\"567\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16cf46ff",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "## Summary\n",
    "It's your turn, what have we learned today?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f8ab521",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "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.11.8"
  },
  "nbTranslate": {
   "displayLangs": [
    "en",
    "es"
   ],
   "hotkey": "alt-a",
   "langInMainMenu": true,
   "sourceLang": "es",
   "targetLang": "en",
   "useGoogleTranslate": true
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "165px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}