Python_Keywords_List.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<small><small><i>\n",
    "All the IPython Notebooks in **Python Introduction** lecture series by **[Dr. Milaan Parmar](https://www.linkedin.com/in/milaanparmar/)** are available @ **[GitHub](https://github.com/milaan9/01_Python_Introduction)**\n",
    "</i></small></small>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List of Keywords in Python\n",
    "\n",
    "This class provides brief information on all keywords used in Python.\n",
    "\n",
    "Keywords are the reserved words in Python. We cannot use a keyword as a variable name, function name or any other identifier.\n",
    "\n",
    "Here's a list of all 36 keywords in Python (3.9) Programming "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Keywords in Python**\n",
    "\n",
    "|    |    |    |   |    |\n",
    "|:----|:----|:----|:----|:----|\n",
    "| **`False`** | **`break`** | **`for`** | **`not`** |\n",
    "| **`None`**  | **`class`** | **`from`** | **`or`** |\n",
    "| **`True`**  | **`continue`** | **`global`** | **`pass`** |\n",
    "| **`__peg_parser__`** |**`def`** | **`if`** | **`raise`** |\n",
    "| **`and`** | **`del`** | **`import`** | **`return`** |\n",
    "| **`as`** | **`elif`** | **`in`** | **`try`** |\n",
    "| **`assert`** | **`else`** | **`is`** | **`while`** |\n",
    "| **`async`** | **`except`** | **`lambda`** | **`with`** |\n",
    "| **`await`** | **`finally`** | **`nonlocal`** |  **`yield`**  |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above keywords may get altered in different versions of Python. Some extra might get added or some might be removed. You can always get the list of keywords in your current version by typing the following in the prompt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-19T09:43:24.470010Z",
     "start_time": "2021-06-19T09:43:24.458782Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']\n"
     ]
    }
   ],
   "source": [
    "import keyword\n",
    "print(keyword.kwlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Description of Keywords in Python with examples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `True`, `False`\n",
    "\n",
    "**`True`** and **`False`** are truth values in Python. They are the results of comparison operations or logical (Boolean) operations in Python. For example:\n",
    "\n",
    "```python\n",
    ">>> 1 == 1\n",
    "True\n",
    ">>> 5 > 3\n",
    "True\n",
    ">>> True or False\n",
    "True\n",
    ">>> 10 <= 1\n",
    "False\n",
    ">>> 3 > 7\n",
    "False\n",
    ">>> True and False\n",
    "False\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we can see that the first three statements are true so the interpreter returns **`True`** and returns **`False`** for the remaining three statements. **`True`** and **`False`** in python is same as **`1`** and **`0`**. This can be justified with the following example:\n",
    "\n",
    "```python\n",
    ">>> True == 1\n",
    "True\n",
    ">>> False == 0\n",
    "True\n",
    ">>> True + True\n",
    "2\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `None`\n",
    "\n",
    "**`None`** is a special constant in Python that represents the absence of a value or a null value.\n",
    "\n",
    "It is an object of its own datatype, the **`NoneType`**. We cannot create multiple **`None`** objects but can assign it to variables. These variables will be equal to one another.\n",
    "\n",
    "We must take special care that **`None`** does not imply **`False`**, **`0`** or any empty list, dictionary, string etc. For example:\n",
    "\n",
    "```python\n",
    ">>> None == 0\n",
    "False\n",
    ">>> None == []\n",
    "False\n",
    ">>> None == False\n",
    "False\n",
    ">>> x = None\n",
    ">>> y = None\n",
    ">>> x == y\n",
    "True\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Void functions that do not return anything will return a **`None`** object automatically. **`None`** is also returned by functions in which the program flow does not encounter a return statement. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-19T09:43:27.810796Z",
     "start_time": "2021-06-19T09:43:27.803964Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "def a_void_function():\n",
    "    a = 1\n",
    "    b = 2\n",
    "    c = a + b\n",
    "\n",
    "x = a_void_function()\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This program has a function that does not return a value, although it does some operations inside. So when we print **`x`**, we get **`None`** which is returned automatically (implicitly). Similarly, here is another example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-19T09:43:28.518797Z",
     "start_time": "2021-06-19T09:43:28.507083Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "def improper_return_function(a):\n",
    "    if (a % 2) == 0:\n",
    "        return True\n",
    "\n",
    "x = improper_return_function(3)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Although this function has a **`return`** statement, it is not reached in every case. The function will return **`True`** only when the input is even.\n",
    "\n",
    "If we give the function an odd number, **`None`** is returned implicitly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `__peg_parser__`\n",
    "\n",
    "The **`__peg_parser__`** keyword is a new keyword in Python 3.9. The **`__new_parser__`** was renamed to **`__peg_parser__`** recently."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `and`, `or` , `not`\n",
    "\n",
    "**`and`**, **`or`** , **`not`** are the logical operators in Python. **`and`** will result into **`True`** only if both the operands are **`True`**. The truth table for **`and`** is given below:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Truth table for `and`**\n",
    "\n",
    "| A | B | A `and` B | \n",
    "|:----| :--- |:--- |\n",
    "| **`True`**  | **`True`**  | **`True`**  | \n",
    "| **`True`**  | **`False`** | **`False`** |\n",
    "| **`False`** | **`True`**  | **`False`** |\n",
    "| **`False`** | **`False`** | **`False`** |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`or`** will result into **`True`** if any of the operands is **`True`**. The truth table for **`or`** is given below:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Truth table for `or`**\n",
    "\n",
    "| A | B | A `or` B | \n",
    "|:----| :--- |:--- |\n",
    "| **`True`**  | **`True`**  | **`True`**  | \n",
    "| **`True`**  | **`False`** | **`True`** |\n",
    "| **`False`** | **`True`**  | **`True`** |\n",
    "| **`False`** | **`False`** | **`False`** |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`not`** operator is used to invert the truth value. The truth table for **`not`** is given below:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Truth table for `not`**\n",
    "\n",
    "| A | `not` A |\n",
    "|:----| :--- |\n",
    "| **`True`**  | **`False`** |\n",
    "| **`False`** | **`True`**  | "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "some example of their usage are given below:\n",
    "\n",
    "```python\n",
    ">>> True and False\n",
    "False\n",
    ">>> True or False\n",
    "True\n",
    ">>> not False\n",
    "True\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `as`\n",
    "\n",
    "**`as`** is used to create an alias while importing a module. It means giving a different name (user-defined) to a module while importing it.\n",
    "\n",
    "As for example, Python has a standard module called **`math`**. Suppose we want to calculate what **cosine pi** is using an alias. We can do it as follows using **`as`**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-19T09:43:33.324901Z",
     "start_time": "2021-06-19T09:43:33.306351Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math as myAlias\n",
    "myAlias.cos(myAlias.pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we imported the **`math`** module by giving it the name **`myAlias`**. Now we can refer to the **`math`** module with this name. Using this name we calculated **cos(pi)** and got **`-1.0`** as the answer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `assert`\n",
    "\n",
    "**`assert`** is used for debugging purposes.\n",
    "\n",
    "While programming, sometimes we wish to know the internal state or check if our assumptions are true. **`assert`** helps us do this and find bugs more conveniently. **`assert`** is followed by a condition.\n",
    "\n",
    "If the condition is true, nothing happens. But if the condition is false, **`AssertionError`** is raised. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-19T09:43:35.078791Z",
     "start_time": "2021-06-19T09:43:34.755556Z"
    }
   },
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-5-4f2812c1d2fe>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0ma\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m4\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;32massert\u001b[0m \u001b[0ma\u001b[0m \u001b[1;33m<\u001b[0m \u001b[1;36m5\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[1;32massert\u001b[0m \u001b[0ma\u001b[0m \u001b[1;33m>\u001b[0m \u001b[1;36m5\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAssertionError\u001b[0m: "
     ]
    }
   ],
   "source": [
    "a = 4\n",
    "assert a < 5\n",
    "assert a > 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For our better understanding, we can also provide a message to be printed with the **`AssertionError`**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-19T09:43:35.802903Z",
     "start_time": "2021-06-19T09:43:35.780446Z"
    }
   },
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "The value of a is too small",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-6-d8a5f223bb50>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0ma\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m4\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[1;32massert\u001b[0m \u001b[0ma\u001b[0m \u001b[1;33m>\u001b[0m \u001b[1;36m5\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"The value of a is too small\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAssertionError\u001b[0m: The value of a is too small"
     ]
    }
   ],
   "source": [
    "a = 4\n",
    "assert a > 5, \"The value of a is too small\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At this point we can note that,\n",
    "\n",
    "```python\n",
    "assert condition, message\n",
    "```\n",
    "is equivalent to,\n",
    "\n",
    "```python\n",
    "if not condition:\n",
    "    raise AssertionError(message)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `async`, `await`\n",
    "\n",
    "The **`async`** and **`await`** keywords are provided by the **`asyncio`** library in Python. They are used to write concurrent code in Python. For example,\n",
    "\n",
    "```python\n",
    "import asyncio\n",
    "\n",
    "async def main():\n",
    "    print('Hello')\n",
    "    await asyncio.sleep(1)\n",
    "    print('world')\n",
    "```\n",
    "\n",
    "To run the program, we use\n",
    "\n",
    "```python\n",
    "asyncio.run(main())\n",
    "```\n",
    "\n",
    "In the above program, the **`async`** keyword specifies that the function will be executed asynchronously.\n",
    "\n",
    "Here, first **`Hello`** is printed. The **`await`** keyword makes the program wait for 1 second. And then the **`world`** is printed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `break`, `continue`\n",
    "\n",
    "**`break`** and **`continue`** are used inside for and while loops to alter their normal behavior.\n",
    "\n",
    "**`break`** will end the smallest loop it is in and control flows to the statement immediately below the loop. **`continue`** causes to end the current iteration of the loop, but not the whole loop.\n",
    "\n",
    "This can be illustrated with the following two examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-19T09:43:41.071408Z",
     "start_time": "2021-06-19T09:43:41.059691Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,11):\n",
    "    if i == 5:\n",
    "        break\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, the **`for`** loop intends to print numbers from 1 to 10. But the **`if`** condition is met when **`i`** is equal to 5 and we break from the loop. Thus, only the range 1 to 4 is printed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-19T09:43:42.150987Z",
     "start_time": "2021-06-19T09:43:42.141223Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,11):\n",
    "    if i == 5:\n",
    "        continue\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we use **`continue`** for the same program. So, when the condition is met, that iteration is skipped. But we do not exit the loop. Hence, all the values except 5 are printed out.\n",
    "\n",
    "Learn more about [**Python break and continue statement**](https://github.com/milaan9/03_Python_Flow_Control/blob/main/007_Python_break_continue_pass_statements.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `class`\n",
    "\n",
    "**`class`** is used to define a new user-defined class in Python.\n",
    "\n",
    "Class is a collection of related attributes and methods that try to represent a real-world situation. This idea of putting data and functions together in a class is central to the concept of object-oriented programming (OOP).\n",
    "\n",
    "Classes can be defined anywhere in a program. But it is a good practice to define a single class in a module. Following is a sample usage:\n",
    "\n",
    "```python\n",
    "class ExampleClass:\n",
    "    def function1(parameters):\n",
    "        …\n",
    "    def function2(parameters):\n",
    "        …\n",
    "```\n",
    "\n",
    "Learn more about [**Python Objects and Class**](https://github.com/milaan9/06_Python_Object_Class/blob/main/002_Python_Classes_and_Objects.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `def`\n",
    "\n",
    "**`def`** is used to define a user-defined function.\n",
    "\n",
    "Function is a block of related statements, which together does some specific task. It helps us organize code into manageable chunks and also to do some repetitive task.\n",
    "\n",
    "The usage of **`def`** is shown below:\n",
    "\n",
    "```python\n",
    "def function_name(parameters):\n",
    "    …\n",
    "```\n",
    "\n",
    "Learn more about [**Python functions**](https://github.com/milaan9/04_Python_Functions/blob/main/001_Python_Functions.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `del`\n",
    "\n",
    "**`del`** is used to delete the reference to an object. Everything is object in Python. We can delete a variable reference using **`del`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-19T09:43:46.085030Z",
     "start_time": "2021-06-19T09:43:46.059642Z"
    }
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'a' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-9-22a6e3d7d570>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0ma\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m5\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;32mdel\u001b[0m \u001b[0ma\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0ma\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'a' is not defined"
     ]
    }
   ],
   "source": [
    "a = b = 5\n",
    "del a\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-19T09:43:47.992239Z",
     "start_time": "2021-06-19T09:43:47.980523Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we can see that the reference of the variable a was deleted. So, it is no longer defined. But **`b`** still exists.\n",
    "\n",
    "**`del`** is also used to delete items from a list or a dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-19T09:43:49.220740Z",
     "start_time": "2021-06-19T09:43:49.203166Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['x', 'z']"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = ['x','y','z']\n",
    "del a[1]\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `if`, `else`, `elif`\n",
    "\n",
    "**`if`**, **`else`**, **`elif`** are used for conditional branching or decision making.\n",
    "\n",
    "When we want to test some condition and execute a block only if the condition is true, then we use **`if`** and **`elif`**. **`elif`** is short for else if. **`else`** is the block which is executed if the condition is false. This will be clear with the following example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-19T09:43:50.100128Z",
     "start_time": "2021-06-19T09:43:50.091342Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Two\n",
      "Something else\n",
      "One\n"
     ]
    }
   ],
   "source": [
    "def if_example(a):\n",
    "    if a == 1:\n",
    "        print('One')\n",
    "    elif a == 2:\n",
    "        print('Two')\n",
    "    else:\n",
    "        print('Something else')\n",
    "\n",
    "if_example(2)\n",
    "if_example(4)\n",
    "if_example(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, the function checks the input number and prints the result if it is 1 or 2. Any input other than this will cause the **`else`** part of the code to execute.\n",
    "\n",
    "Learn more about [**Python if**](https://github.com/milaan9/03_Python_Flow_Control/blob/main/001_Python_if_statement.ipynb), [**if-else**](https://github.com/milaan9/03_Python_Flow_Control/blob/main/002_Python_if_else_statement.ipynb) and [**if-elif-else**](https://github.com/milaan9/03_Python_Flow_Control/blob/main/003_Python_if_elif_else_statement%20.ipynb) Statement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `except`, `raise`, `try`\n",
    "\n",
    "**`except`**, **`raise`**, **`try`** are used with exceptions in Python.\n",
    "\n",
    "Exceptions are basically errors that suggests something went wrong while executing our program. **`IOError`**, **`ValueError`**, **`ZeroDivisionError`**, **`ImportError`**, **`NameError`**, **`TypeError`** etc. are few examples of exception in Python. **`try...except`** blocks are used to catch exceptions in Python.\n",
    "\n",
    "We can raise an exception explicitly with the **`raise`** keyword. Following is an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-19T09:43:51.669450Z",
     "start_time": "2021-06-19T09:43:51.650896Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.1\n",
      "Exception caught\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "def reciprocal(num):\n",
    "    try:\n",
    "        r = 1/num\n",
    "    except:\n",
    "        print('Exception caught')\n",
    "        return\n",
    "    return r\n",
    "\n",
    "print(reciprocal(10))\n",
    "print(reciprocal(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, the function **`reciprocal()`** returns the reciprocal of the input number.\n",
    "\n",
    "When we enter 10, we get the normal output of 0.1. But when we input 0, a **`ZeroDivisionError`** is raised automatically.\n",
    "\n",
    "This is caught by our **`try…except`** block and we return **`None`**. We could have also raised the **`ZeroDivisionError`** explicitly by checking the input and handled it elsewhere as follows:\n",
    "\n",
    "```python\n",
    "if num == 0:\n",
    "    raise ZeroDivisionError('cannot divide')\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `finally`\n",
    "\n",
    "**`finally`** is used with **`try…except`** block to close up resources or file streams.\n",
    "\n",
    "Using **`finally`** ensures that the block of code inside it gets executed even if there is an unhandled exception. For example:\n",
    "\n",
    "```python\n",
    "try:\n",
    "    Try-block\n",
    "except exception1:\n",
    "    Exception1-block\n",
    "except exception2:\n",
    "    Exception2-block\n",
    "else:\n",
    "    Else-block\n",
    "finally:\n",
    "    Finally-block\n",
    "```\n",
    "\n",
    "Here if there is an exception in the **`Try-block`**, it is handled in the **`except`** or **`else`** block. But no matter in what order the execution flows, we can rest assured that the **`Finally-block`** is executed even if there is an error. This is useful in cleaning up the resources.\n",
    "\n",
    "Learn more about [**exception handling in Python programming**](https://github.com/milaan9/05_Python_Files/blob/main/004_Python_Exceptions_Handling.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `for`\n",
    "\n",
    "**`for`** is used for looping. Generally we use **`for`** when we know the number of times we want to loop.\n",
    "\n",
    "In Python we can use it with any type of sequences like a list or a string. Here is an example in which **`for`** is used to traverse through a list of names:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-19T09:43:54.035150Z",
     "start_time": "2021-06-19T09:43:54.019531Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello John\n",
      "Hello Monica\n",
      "Hello Steven\n",
      "Hello Robin\n"
     ]
    }
   ],
   "source": [
    "names = ['John','Monica','Steven','Robin']\n",
    "for i in names:\n",
    "    print('Hello '+i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Learn more about [**Python for loop**](https://github.com/milaan9/03_Python_Flow_Control/blob/main/005_Python_for_Loop.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `from`, `import`\n",
    "\n",
    "**`import`** keyword is used to import modules into the current namespace. **`from…import`** is used to import specific attributes or functions into the current namespace. For example:\n",
    "\n",
    "```python\n",
    "import math\n",
    "```\n",
    "\n",
    "will import the **`math`** module. Now we can use the **`cos()`** function inside it as **`math.cos()`**. But if we wanted to import just the **`cos()`** function, this can done using **`from`** as\n",
    "\n",
    "```python\n",
    "from math import cos\n",
    "```\n",
    "\n",
    "now we can use the function simply as **`cos()`**, no need to write **`math.cos()`**.\n",
    "\n",
    "Learn more on [**Python modules and import statement**](https://github.com/milaan9/04_Python_Functions/blob/main/007_Python_Function_Module.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `global`\n",
    "\n",
    "**`global`** is used to declare that a variable inside the function is global (outside the function).\n",
    "\n",
    "If we need to read the value of a global variable, it is not necessary to define it as **`global`**. This is understood.\n",
    "\n",
    "If we need to modify the value of a global variable inside a function, then we must declare it with **`global`**. Otherwise, a local variable with that name is created.\n",
    "\n",
    "Following example will help us clarify this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-19T09:43:56.504850Z",
     "start_time": "2021-06-19T09:43:56.483860Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "5\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "globvar = 10\n",
    "def read1():\n",
    "    print(globvar)\n",
    "def write1():\n",
    "    global globvar\n",
    "    globvar = 5\n",
    "def write2():\n",
    "    globvar = 15\n",
    "\n",
    "read1()\n",
    "write1()\n",
    "read1()\n",
    "write2()\n",
    "read1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, the **`read1()`** function is just reading the value of **`globvar`**. So, we do not need to declare it as **`global`**. But the **`write1()`** function is modifying the value, so we need to declare the variable as **`global`**.\n",
    "\n",
    "We can see in our output that the modification did take place (10 is changed to 5). The **`write2()`** also tries to modify this value. But we have not declared it as **`global`**.\n",
    "\n",
    "Hence, a new local variable **`globvar`** is created which is not visible outside this function. Although we modify this local variable to 15, the global variable remains unchanged. This is clearly visible in our output."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `in`\n",
    "\n",
    "**`in`** is used to test if a sequence (list, tuple, string etc.) contains a value. It returns **`True`** if the value is present, else it returns **`False`**. For example:\n",
    "\n",
    "```python\n",
    ">>> a = [1, 2, 3, 4, 5]\n",
    ">>> 5 in a\n",
    "True\n",
    ">>> 10 in a\n",
    "False\n",
    "```\n",
    "\n",
    "The secondary use of in is to traverse through a sequence in a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-19T09:43:58.332470Z",
     "start_time": "2021-06-19T09:43:58.324661Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "h\n",
      "e\n",
      "l\n",
      "l\n",
      "o\n"
     ]
    }
   ],
   "source": [
    "for i in 'hello':\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `is`\n",
    "\n",
    "**`is`** is used in Python for testing object identity. While the **`==`** operator is used to test if two variables are equal or not, **`is`** is used to test if the two variables refer to the same object.\n",
    "\n",
    "It returns **`True`** if the objects are identical and **`False`** if not.\n",
    "\n",
    "```python\n",
    ">>> True is True\n",
    "True\n",
    ">>> False is False\n",
    "True\n",
    ">>> None is None\n",
    "True\n",
    "```\n",
    "\n",
    "We know that there is only one instance of **`True`**, **`False`** and **`None`** in Python, so they are identical.\n",
    "\n",
    "```python\n",
    ">>> [] == []\n",
    "True\n",
    ">>> [] is []\n",
    "False\n",
    ">>> {} == {}\n",
    "True\n",
    ">>> {} is {}\n",
    "False\n",
    "```\n",
    "\n",
    "An empty list or dictionary is equal to another empty one. But they are not identical objects as they are located separately in memory. This is because list and dictionary are mutable (value can be changed).\n",
    "\n",
    "```python\n",
    ">>> '' == ''\n",
    "True\n",
    ">>> '' is ''\n",
    "True\n",
    ">>> () == ()\n",
    "True\n",
    ">>> () is ()\n",
    "True\n",
    "```\n",
    "\n",
    "Unlike list and dictionary, string and tuple are immutable (value cannot be altered once defined). Hence, two equal string or tuple are identical as well. They refer to the same memory location."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `lambda`\n",
    "\n",
    "**`lambda`** is used to create an anonymous function (function with no name). It is an inline function that does not contain a **`return`** statement. It consists of an expression that is evaluated and returned. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-19T09:43:59.963805Z",
     "start_time": "2021-06-19T09:43:59.939391Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "a = lambda x: x*2\n",
    "for i in range(1,6):\n",
    "    print(a(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we have created an inline function that doubles the value, using the **`lambda`** statement. We used this to double the values in a list containing 1 to 5.\n",
    "\n",
    "Learn more about [**Python lamda function**](https://github.com/milaan9/04_Python_Functions/blob/main/006_Python_Function_Anonymous.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `nonlocal`\n",
    "\n",
    "The use of **`nonlocal`** keyword is very much similar to the **`global`** keyword. **`nonlocal`** is used to declare that a variable inside a nested function (function inside a function) is not local to it, meaning it lies in the outer inclosing function. If we need to modify the value of a non-local variable inside a nested function, then we must declare it with **`nonlocal`**. Otherwise a local variable with that name is created inside the nested function. Following example will help us clarify this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-19T09:44:01.622479Z",
     "start_time": "2021-06-19T09:44:01.611739Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inner function:  10\n",
      "Outer function:  10\n"
     ]
    }
   ],
   "source": [
    "def outer_function():\n",
    "    a = 5\n",
    "    def inner_function():\n",
    "        nonlocal a\n",
    "        a = 10\n",
    "        print(\"Inner function: \",a)\n",
    "    inner_function()\n",
    "    print(\"Outer function: \",a)\n",
    "\n",
    "outer_function()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, the **`inner_function()`** is nested within the **`outer_function`**.\n",
    "\n",
    "The variable **`a`** is in the **`outer_function()`**. So, if we want to modify it in the **`inner_function()`**, we must declare it as **`nonlocal`**. Notice that a is not a global variable.\n",
    "\n",
    "Hence, we see from the output that the variable was successfully modified inside the nested **`inner_function()`**. The result of not using the **`nonlocal`** keyword is as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-19T09:44:03.112698Z",
     "start_time": "2021-06-19T09:44:03.100005Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inner function:  10\n",
      "Outer function:  5\n"
     ]
    }
   ],
   "source": [
    "def outer_function():\n",
    "    a = 5\n",
    "    def inner_function():\n",
    "        a = 10\n",
    "        print(\"Inner function: \",a)\n",
    "    inner_function()\n",
    "    print(\"Outer function: \",a)\n",
    "\n",
    "outer_function()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we do not declare that the variable **`a`** inside the nested function is **`nonlocal`**. Hence, a new local variable with the same name is created, but the non-local **`a`** is not modified as seen in our output."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `pass`\n",
    "\n",
    "**`pass`** is a null statement in Python. Nothing happens when it is executed. It is used as a placeholder.\n",
    "\n",
    "Suppose we have a function that is not implemented yet, but we want to implement it in the future. Simply writing,\n",
    "\n",
    "```python\n",
    "def function(args):\n",
    "```\n",
    "\n",
    "in the middle of a program will give us **`IndentationError`**. Instead of this, we construct a blank body with the **`pass`** statement.\n",
    "\n",
    "```python\n",
    "def function(args):\n",
    "    pass\n",
    "```\n",
    "\n",
    "We can do the same thing in an empty **`class`** as well.\n",
    "\n",
    "```python\n",
    "class example:\n",
    "    pass\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `return`\n",
    "\n",
    "**`return`** statement is used inside a function to exit it and return a value.\n",
    "\n",
    "If we do not return a value explicitly, **`None`** is returned automatically. This is verified with the following example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-19T09:44:05.434453Z",
     "start_time": "2021-06-19T09:44:05.419808Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "def func_return():\n",
    "    a = 10\n",
    "    return a\n",
    "\n",
    "def no_return():\n",
    "    a = 10\n",
    "\n",
    "print(func_return())\n",
    "print(no_return())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `while`\n",
    "\n",
    "**`while`** is used for looping in Python.\n",
    "\n",
    "The statements inside a **`while`** loop continue to execute until the condition for the **`while`** loop evaluates to **`False`** or a **`break`** statement is encountered. Following program illustrates this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-19T09:44:06.785511Z",
     "start_time": "2021-06-19T09:44:06.764033Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "4\n",
      "3\n",
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "i = 5\n",
    "while(i):\n",
    "    print(i)\n",
    "    i = i - 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Note:** that 0 is equal to **`False`**.\n",
    "\n",
    "Learn more about [**Python while loop**](https://github.com/milaan9/03_Python_Flow_Control/blob/main/006_Python_while_Loop.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `with`\n",
    "\n",
    "**`with`** statement is used to wrap the execution of a block of code within methods defined by the context manager.\n",
    "\n",
    "Context manager is a class that implements**`__enter__`**and **`__exit__`** methods. Use of with statement ensures that the **`__exit__`** method is called at the end of the nested block. This concept is similar to the use of **`try…finally`** block. Here, is an example.\n",
    "\n",
    "```python\n",
    "with open('example.txt', 'w') as my_file:\n",
    "    my_file.write('Hello world!')\n",
    "```\n",
    "\n",
    "This example writes the text **`Hello world!`** to the  **`example.txt`**. File objects have **`__enter__`** and **`__exit__`** method defined within them, so they act as their own context manager.\n",
    "\n",
    "First the **`__enter__`** method is called, then the code within **`with`** statement is executed and finally the **`__exit__`** method is called. **`__exit__`** method is called even if there is an error. It basically closes the file stream."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `yield`\n",
    "\n",
    "**`yield`** is used inside a function like a **`return`** statement. But **`yield`** returns a generator.\n",
    "\n",
    "Generator is an iterator that generates one item at a time. A large list of values will take up a lot of memory. Generators are useful in this situation as it generates only one value at a time instead of storing all the values in memory. For example,\n",
    "\n",
    "```python\n",
    ">>> g = (2**x for x in range(100))\n",
    "```\n",
    "\n",
    "will create a generator **`g`** which generates powers of 2 up to the number two raised to the power 99. We can generate the numbers using the **`next()`** function as shown below.\n",
    "\n",
    "```python\n",
    ">>> next(g)\n",
    "1\n",
    ">>> next(g)\n",
    "2\n",
    ">>> next(g)\n",
    "4\n",
    ">>> next(g)\n",
    "8\n",
    ">>> next(g)\n",
    "16\n",
    "```\n",
    "\n",
    "And so on… This type of generator is returned by the **`yield`** statement from a function. Here is an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-19T09:44:13.750287Z",
     "start_time": "2021-06-19T09:44:13.732714Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "4\n",
      "9\n",
      "16\n",
      "25\n"
     ]
    }
   ],
   "source": [
    "def generator():\n",
    "    for i in range(6):\n",
    "        yield i*i\n",
    "\n",
    "g = generator()\n",
    "for i in g:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, the function **`generator()`** returns a generator that generates square of numbers from 0 to 5. This is printed in the **`for`** loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.10.9"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}