Tutorials/Intro_to_python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Ja48055HN0B6"
   },
   "source": [
    "# Python Hello World"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "UGwEY1FDN0CB",
    "outputId": "fc649221-91f2-4492-a12d-ead8f143cb81"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n",
      "Hello World\n",
      "Hello 1 True\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello World\")\n",
    "print(\"Hello\", \"World\")\n",
    "print(\"Hello\", 1, True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "3YI9a0mqN0CC"
   },
   "outputs": [],
   "source": [
    "x=\"Good\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "0x0wyJpFN0CD",
    "outputId": "809e6474-67f2-4180-e0a7-bfbaa8435105"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Good Bye\n"
     ]
    }
   ],
   "source": [
    "print(x, \"Bye\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "sbo1nhXvN0CD"
   },
   "source": [
    "# This is Markdown\n",
    "It can be used for explanations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "vLQt7SMSN0CE",
    "outputId": "01d4dc96-8df9-4018-89dc-b2c5dace2e7a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 1\n"
     ]
    }
   ],
   "source": [
    "#This is a comment\n",
    "#Below is how to define a variable\n",
    "x=1\n",
    "print('x =',x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "hw2genjaN0CE",
    "outputId": "3d9b40f4-e855-4001-9d5d-b2576cf30420"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nThis is a multiline comment (and a string too :D)\\nUseful for long documentation\\n'"
      ]
     },
     "execution_count": 3,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "This is a multiline comment (and a string too :D)\n",
    "Useful for long documentation\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EjAOOTZNN0CF"
   },
   "source": [
    "## Python is Dynamically typed and Strong Typed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "RZy99OycN0CF",
    "outputId": "c4cd4645-8eb7-447c-a4de-17f080c7df06"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 1 \t\t\t=> with type <class 'int'>\n",
      "x = 2.5 \t\t=> with type <class 'float'>\n",
      "x = 1.1e+18 \t\t=> with type <class 'float'>\n",
      "x = True \t\t=> with type <class 'bool'>\n",
      "x = Hello World \t=> with type <class 'str'>\n",
      "x = \"Hello World\" \t=> with type <class 'str'>\n",
      "x = (1+2j) \t\t=> with type <class 'complex'>\n",
      "\n",
      "x = [1, 2, 3] \t\t=> with type <class 'list'>\n",
      "x = (1, 2, 3) \t\t=> with type <class 'tuple'>\n",
      "x = (1,) \t\t=> with type <class 'tuple'>\n",
      "x = {1, 2, 3} \t\t=> with type <class 'set'>\n",
      "x = {'a': 1, 'b': 2, 'c': 3} \t\t=> with type <class 'dict'>\n",
      "x = None \t\t=> with type <class 'NoneType'>\n"
     ]
    }
   ],
   "source": [
    "#Variables can change types dynamically\n",
    "x=1\n",
    "print('x =', x, '\\t\\t\\t=> with type', type(x))\n",
    "\n",
    "x=2.5\n",
    "print('x =', x, '\\t\\t=> with type', type(x))\n",
    "\n",
    "x=1.1e18\n",
    "print('x =', x, '\\t\\t=> with type', type(x))\n",
    "\n",
    "x=True #True with Uppercase T and False with Uppercase F\n",
    "print('x =', x, '\\t\\t=> with type', type(x))\n",
    "\n",
    "x=\"Hello World\"\n",
    "print('x =', x, '\\t=> with type', type(x))\n",
    "\n",
    "x='\"Hello World\"'\n",
    "print('x =', x, '\\t=> with type', type(x))\n",
    "\n",
    "x=1+2j\n",
    "print('x =', x, '\\t\\t=> with type', type(x))\n",
    "\n",
    "print()\n",
    "\n",
    "x=[1,2,3]\n",
    "print('x =', x, '\\t\\t=> with type', type(x))\n",
    "\n",
    "x=(1,2,3)\n",
    "print('x =', x, '\\t\\t=> with type', type(x))\n",
    "\n",
    "x=(1,)\n",
    "print('x =', x, '\\t\\t=> with type', type(x))\n",
    "\n",
    "x={1,2,3}\n",
    "print('x =', x, '\\t\\t=> with type', type(x))\n",
    "\n",
    "x={'a':1, 'b':2, 'c':3}\n",
    "print('x =', x, '\\t\\t=> with type', type(x))\n",
    "\n",
    "x=None\n",
    "print('x =', x, '\\t\\t=> with type', type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "_URY2FVWN0CG",
    "outputId": "e2fe3924-675a-4e8f-af47-20d3b9586686"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 1 \t\t=> with type <class 'int'>\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'x' 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-5-c8af3c90c366>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;32mdel\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'x ='\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'\\t\\t=> with type'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtype\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'x' is not defined"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "print('x =', x, '\\t\\t=> with type', type(x))\n",
    "\n",
    "del x\n",
    "print('x =', x, '\\t\\t=> with type', type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "cVW6bAjfN0CG",
    "outputId": "a80cf726-1dcc-4944-c918-ef71e8819366"
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "must be str, not int",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-6-38dbfd71f17f>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m#python is also strongly typed so it will not implicitly change types\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mx\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"This number is \"\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;36m12\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: must be str, not int"
     ]
    }
   ],
   "source": [
    "#python is also strongly typed so it will not implicitly change types\n",
    "x = \"This number is \" + 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "oVQ2YejWN0CH",
    "outputId": "043cd276-a04b-4f53-afe5-238aafeff855"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This number is 12\n",
      "25\n"
     ]
    }
   ],
   "source": [
    "#but you can cast variable if you wish\n",
    "x = \"This number is \" + str(12)\n",
    "print(x)\n",
    "x = int(\"13\") + 12\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Lawj8avtN0CH"
   },
   "source": [
    "# Python Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "2yfTjoQmN0CI",
    "outputId": "304a9dba-d84c-4ff1-9b88-e9969f0b7d2c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x+y =  9\n",
      "x-y =  -1\n",
      "x*y =  20\n",
      "x/y =  0.8\n",
      "x//y =  0\n",
      "x%y =  4\n",
      "x**y =  1024\n"
     ]
    }
   ],
   "source": [
    "x, y = 4, 5\n",
    "print('x+y = ', x+y)\n",
    "print('x-y = ', x-y)\n",
    "print('x*y = ', x*y)\n",
    "print('x/y = ', x/y)\n",
    "print('x//y = ', x//y)\n",
    "print('x%y = ', x%y)\n",
    "print('x**y = ', x**y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "L6n1b2kXN0CI",
    "outputId": "5ff8a557-028c-4582-96a6-286378bc4d0d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x==y =  False\n",
      "x!=y =  True\n",
      "x<y =  True\n",
      "x>y =  False\n",
      "x<=y =  True\n",
      "x>=y =  False\n"
     ]
    }
   ],
   "source": [
    "x, y = 4, 5\n",
    "print('x==y = ', x==y)\n",
    "print('x!=y = ', x!=y)\n",
    "print('x<y = ', x<y)\n",
    "print('x>y = ', x>y)\n",
    "print('x<=y = ', x<=y)\n",
    "print('x>=y = ', x>=y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "hfA8cdF9N0CI",
    "outputId": "36d2c623-aab5-4536-c67a-765cd97ce018"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x and y =  False\n",
      "x or y =  True\n",
      "not x =  False\n"
     ]
    }
   ],
   "source": [
    "x, y = True, False\n",
    "print('x and y = ', x and y)\n",
    "print('x or y = ', x or y)\n",
    "print('not x = ', not x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "m1OJ8Ts-N0CJ",
    "outputId": "4a25cc16-4623-44ed-9402-3a7e8052e494"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x & y =  0b1\n",
      "x | y =  0b111\n",
      "~ x =  -0b110\n",
      "x ^ y =  0b110\n",
      "x << 1 0b1010\n",
      "x >> 1 0b10\n"
     ]
    }
   ],
   "source": [
    "x, y = 0b0101, 0b0011\n",
    "print('x & y = ', bin(x & y))\n",
    "print('x | y = ', bin(x | y))\n",
    "print('~ x = ', bin(~ x))\n",
    "print('x ^ y = ', bin(x ^ y))\n",
    "print('x << 1', bin(x << 1))\n",
    "print('x >> 1', bin(x >> 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "G4Bsw2svN0CJ",
    "outputId": "b33b073b-d00f-4eac-dd55-b9545b5a7c4f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x+y = HelloWorld\n",
      "x*3 = HelloHelloHello\n",
      "ascii of \"h\" =  104\n",
      "char for 104 =  h\n"
     ]
    }
   ],
   "source": [
    "x, y = 'Hello', \"World\"\n",
    "print('x+y =', x+y)\n",
    "print('x*3 =', x*3)\n",
    "print('ascii of \"h\" = ', ord('h'))\n",
    "print('char for 104 = ', chr(104))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "KfVNRBhEN0CK",
    "outputId": "3be3dd7a-0287-4137-f9e7-f30aec4d5004"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x+y = [1, 2, 3, 4, 5]\n",
      "x*3 = [1, 2, 3, 1, 2, 3, 1, 2, 3]\n",
      "\n",
      "x+y = (1, 2, 3, 4, 5)\n",
      "x*3 = (1, 2, 3, 1, 2, 3, 1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "x, y = [1,2,3], [4,5]\n",
    "print('x+y =', x+y)\n",
    "print('x*3 =', x*3)\n",
    "\n",
    "print()\n",
    "\n",
    "x, y = (1,2,3), (4,5)\n",
    "print('x+y =', x+y)\n",
    "print('x*3 =', x*3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "sZ3LA-sBN0CK",
    "outputId": "eaa94faf-7f5c-4af5-ae75-97b640c9d78e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1+(2*3) = 7\n"
     ]
    }
   ],
   "source": [
    "#Python is an interpreted language so you can evaluate any string as python code\n",
    "x = \"1+(2*3)\"\n",
    "print(x,'=',eval(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "h3T7rmdGN0CK",
    "outputId": "a6988503-68c6-4ecd-981d-c175ceef9f0d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 2\n",
      "x = 3\n",
      "x = 2\n",
      "x = 10\n",
      "x = 2.0\n",
      "x = 1024.0\n",
      "x = 102.0\n",
      "x = 2.0\n"
     ]
    }
   ],
   "source": [
    "x = 2\n",
    "print('x =', x)\n",
    "x += 1\n",
    "print('x =', x)\n",
    "x -= 1\n",
    "print('x =', x)\n",
    "x *= 5\n",
    "print('x =', x)\n",
    "x /= 5\n",
    "print('x =', x)\n",
    "x **= 10\n",
    "print('x =', x)\n",
    "x //= 10\n",
    "print('x =', x)\n",
    "x %= 10\n",
    "print('x =', x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "6kjXeKadN0CL",
    "outputId": "31a62e8a-e8c7-40c6-cc62-fd0e50806519"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 6\n",
      "x = 2\n",
      "x = 5\n"
     ]
    }
   ],
   "source": [
    "x = 4\n",
    "x |= 2\n",
    "print('x =', x)\n",
    "x &= 2\n",
    "print('x =', x)\n",
    "x ^= 7\n",
    "print('x =', x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "4k-hugdbN0CL",
    "outputId": "add7a437-482b-494e-fda6-b76f493fdf8e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "is 1 in list? = True\n",
      "is 4 in list? = False\n",
      "is 4 not in list? = True\n",
      "ll in hello True\n",
      "x in hello False\n",
      "is 1 in set? = True\n",
      "is 4 in set? = False\n",
      "is 1 in dict? = True\n",
      "is 4 in dict? = False\n"
     ]
    }
   ],
   "source": [
    "x = [1,2,3]\n",
    "print('is 1 in list? =', 1 in x)\n",
    "print('is 4 in list? =', 4 in x)\n",
    "print('is 4 not in list? =', 4 not in x)\n",
    "\n",
    "x='hello'\n",
    "print('ll in hello', 'll' in x)\n",
    "print('x in hello', 'x' in x)\n",
    "\n",
    "x = {1,2,3}\n",
    "print('is 1 in set? =', 1 in x)\n",
    "print('is 4 in set? =', 4 in x)\n",
    "\n",
    "x = {1:'a',2:'b',3:'c'}\n",
    "print('is 1 in dict? =', 1 in x)\n",
    "print('is 4 in dict? =', 4 in x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "RdhWZii1N0CL",
    "outputId": "ee768754-f028-4552-ba1f-31951263ed6b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Same Reference\n",
      "x == y = True\n",
      "x is y = True\n",
      "x is not y = False\n",
      "Different Reference\n",
      "x == y = True\n",
      "x is y = False\n",
      "x is not y = True\n"
     ]
    }
   ],
   "source": [
    "x = [1,2,3]\n",
    "y = x\n",
    "print(\"Same Reference\")\n",
    "print('x == y =', x==y)\n",
    "print('x is y =', x is y)\n",
    "print('x is not y =', x is not y)\n",
    "\n",
    "y = [1,2,3]\n",
    "print(\"Different Reference\")\n",
    "print('x == y =', x==y)\n",
    "print('x is y =', x is y)\n",
    "print('x is not y =', x is not y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "u37qlclLN0CM"
   },
   "source": [
    "# Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "kc85ha8ON0CM",
    "outputId": "9189aa6e-a626-4b25-f8b0-ffedaef62494"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x[0] = H\n",
      "x[-1] = d\n",
      "x[1:3] =  el\n",
      "x[:3] =  Hel\n",
      "x[1:] =  ello World\n",
      "x[:-1] =  Hello Worl\n",
      "x[1:5:2] =  el\n",
      "x[::2] =  HloWrd\n",
      "x[::-1] =  dlroW olleH\n"
     ]
    }
   ],
   "source": [
    "x = 'Hello World'\n",
    "\n",
    "print(\"x[0] =\",x[0])\n",
    "print(\"x[-1] =\", x[-1])\n",
    "print(\"x[1:3] = \", x[1:3]) #slice from 1 (inclusive) to 3 (exclusive)\n",
    "print(\"x[:3] = \", x[:3])\n",
    "print(\"x[1:] = \", x[1:])\n",
    "print(\"x[:-1] = \", x[:-1])\n",
    "print(\"x[1:5:2] = \", x[1:5:2])\n",
    "print(\"x[::2] = \", x[::2])\n",
    "print(\"x[::-1] = \", x[::-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Nz-8rmclN0CM",
    "outputId": "09d3a99c-d26b-41a2-d2de-9cb32c019a1f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "length of x = 11\n",
      "x[-1] = x[len(x)-1] =  d\n",
      "x[0] = x[-len(x)] = H\n"
     ]
    }
   ],
   "source": [
    "x = 'Hello World'\n",
    "\n",
    "print('length of x =', len(x))\n",
    "print('x[-1] = x[len(x)-1] = ', x[len(x)-1])\n",
    "print('x[0] = x[-len(x)] =', x[-len(x)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 189
    },
    "id": "lavZ3XlpN0CN",
    "outputId": "c6092f70-2dbf-4e61-e8ec-935a8e9075bf"
   },
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "ignored",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-3-c85bbb637ee7>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m#error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m#error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mIndexError\u001b[0m: string index out of range"
     ]
    }
   ],
   "source": [
    "print(x[len(x)]) #error\n",
    "print(x[-len(x)-1]) #error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 189
    },
    "id": "xR5ymLa9N0CN",
    "outputId": "9e5959fe-eba4-4917-9865-f57852f6b4f5"
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "ignored",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-4-4456cbe28418>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'Hello World'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'a'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "x = 'Hello World'\n",
    "x[1] = 'a'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "BHHVe7pKN0CN",
    "outputId": "b6c32b6b-62c5-4404-d956-8eadde15bd09"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hallo World\n"
     ]
    }
   ],
   "source": [
    "x = x[0:1] + 'a' + x[2:]\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "_UQ6w2bbN0CN",
    "outputId": "8d17c9d7-dcf8-43b7-96ac-60e8adedb1c2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1', '2', '3', '4']\n",
      "['1', '2', '3', '4']\n"
     ]
    }
   ],
   "source": [
    "x = '1 2 3 4'\n",
    "print(x.split())\n",
    "\n",
    "x = '1/2/3/4'\n",
    "print(x.split('/'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "NYSOPf1wN0CO",
    "outputId": "87df63cc-d0d2-45b0-eb24-ec89777c0a60"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1+2+3+4\n"
     ]
    }
   ],
   "source": [
    "l = ['1','2','3','4']\n",
    "s = '+'.join(l)\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "bvuFOhq3N0CO",
    "outputId": "c0128be3-ead1-4831-d37d-aed37e971b8d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Mazinger, as you know, if x=1, then 2*x+1=3\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "y = \"Mazinger\"\n",
    "print(f'Hello {y}, as you know, if x={x}, then 2*x+1={2*x+1}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "G54HLxgGN0CO"
   },
   "source": [
    "# Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "zP33iH7CN0CP",
    "outputId": "7815a4e3-74af-48e5-b7e6-c66ee854f9ab"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x[0] = 1\n",
      "x[-1] = (1+5j)\n",
      "x[1:3] =  [2, 3]\n",
      "x[:3] =  [1, 2, 3]\n",
      "x[1:] =  [2, 3, 'hello', 1.2, (1+5j)]\n",
      "x[:-1] =  [1, 2, 3, 'hello', 1.2]\n",
      "x[1:5:2] =  [2, 'hello']\n",
      "x[::2] =  [1, 3, 1.2]\n",
      "x[::-1] =  [(1+5j), 1.2, 'hello', 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "x = [1,2,3,'hello',1.2,1+5j]\n",
    "\n",
    "print(\"x[0] =\",x[0])\n",
    "print(\"x[-1] =\", x[-1])\n",
    "print(\"x[1:3] = \", x[1:3]) #slice from 1 (inclusive) to 3 (exclusive)\n",
    "print(\"x[:3] = \", x[:3])\n",
    "print(\"x[1:] = \", x[1:])\n",
    "print(\"x[:-1] = \", x[:-1])\n",
    "print(\"x[1:5:2] = \", x[1:5:2])\n",
    "print(\"x[::2] = \", x[::2])\n",
    "print(\"x[::-1] = \", x[::-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "zhHna9s5N0CP",
    "outputId": "1f36a61d-aa63-47e4-ea5f-325d39b6b272"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 'a', 3, 4, 5]\n",
      "[1, 'add', 'this', 5]\n",
      "[1, 5]\n"
     ]
    }
   ],
   "source": [
    "x = [1,2,3,4,5]\n",
    "\n",
    "x[1] = 'a'\n",
    "print(x)\n",
    "x[1:-1] = ['add', 'this']\n",
    "print(x)\n",
    "x[1:-1] = []\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ePu4WAPcN0CP",
    "outputId": "4c49baee-2f24-4aa2-9633-3895c657f5f1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x =  [1, 'edit', 3, 4, 5]\n",
      "y =  [1, 'edit', 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "x = [1,2,3,4,5]\n",
    "y = x\n",
    "y[1] = 'edit'\n",
    "print('x = ', x)\n",
    "print('y = ', y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "xR3cbYmgN0CQ",
    "outputId": "cacd2489-0557-41d7-bb09-0799f30b5789"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x =  [1, 2, 3, 4, 5]\n",
      "y =  [1, 'edit', 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "x = [1,2,3,4,5]\n",
    "y = x[:]\n",
    "y[1] = 'edit'\n",
    "print('x = ', x)\n",
    "print('y = ', y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "P1r3Dac4N0CQ",
    "outputId": "94ca0267-a0d3-41fa-cabc-04b6d1ee8e59"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 'last']\n",
      "['first', 1, 2, 3, 4, 5, 'last']\n",
      "['first', 1, 2, 'middle', 3, 4, 5, 'last']\n"
     ]
    }
   ],
   "source": [
    "x = [1,2,3,4,5]\n",
    "x.append('last')\n",
    "print(x)\n",
    "x.insert(0, 'first')\n",
    "print(x)\n",
    "x.insert(len(x)//2, 'middle')\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "CrW1ujyCN0CQ",
    "outputId": "a0b60355-8495-49cc-a193-9fa67613a7ba"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n",
      "[2, 3, 4]\n",
      "[2, 4]\n"
     ]
    }
   ],
   "source": [
    "x = [1,2,3,4,5]\n",
    "\n",
    "x.pop()\n",
    "print(x)\n",
    "x.pop(0)\n",
    "print(x)\n",
    "x.pop(len(x)//2)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "XIh447Q-N0CQ",
    "outputId": "29ef1817-6f23-43d0-c7c9-52fddb51338d",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "count of 1 = 3\n",
      "max = 3\n",
      "min = 1\n",
      "first index of 2 = 1\n",
      "reversed = [1, 2, 1, 3, 2, 1]\n",
      "x didn't change = [1, 2, 3, 1, 2, 1]\n",
      "reversed inplace = [1, 2, 1, 3, 2, 1]\n",
      "sorted = [1, 1, 1, 2, 2, 3]\n",
      "x didn't change = [1, 2, 1, 3, 2, 1]\n",
      "sorted inplace = [1, 1, 1, 2, 2, 3]\n",
      "with [4,5] = [1, 1, 1, 2, 2, 3, 4, 5]\n",
      "with 2 = [1, 1, 1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "x = [1,2,3,1,2,1]\n",
    "\n",
    "print('count of 1 =', x.count(1))\n",
    "print('max =', max(x))\n",
    "print('min =', min(x))\n",
    "print('first index of 2 =', x.index(2))\n",
    "\n",
    "#reversing\n",
    "print('reversed =', list(reversed(x)))\n",
    "print('x didn\\'t change =', x)\n",
    "x.reverse() #done inplace\n",
    "print('reversed inplace =', x)\n",
    "\n",
    "#sorting\n",
    "print('sorted =', list(sorted(x)))\n",
    "print('x didn\\'t change =', x)\n",
    "x.sort() #done inplace\n",
    "print('sorted inplace =', x)\n",
    "\n",
    "x.extend([4, 5])\n",
    "print('with [4,5] =', x)\n",
    "x.remove(2)\n",
    "print('with 2 =', x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "dphWhNTbN0CR",
    "outputId": "bb97bbc1-af2b-4021-8113-274c86ca37d1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 1, 2, 1]\n",
      "1 2 3 1 2 1\n"
     ]
    }
   ],
   "source": [
    "x = [1,2,3,1,2,1]\n",
    "print(x)\n",
    "print(*x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "8AKEZoqaN0CR",
    "outputId": "a6cfa44d-0f65-45d2-cc22-0587690d8a60"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 9, 8, 7]\n",
      "[1, 2, 3, 5, 9, 8, 7]\n",
      "[1, 9, 8, 7, 1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "x = [1,2,3]\n",
    "y = [9,8,7]\n",
    "print([*x, *y])\n",
    "print([*x, 5, *y])\n",
    "print([1, *y, *x])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wC4B6hGtN0CR"
   },
   "source": [
    "# Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "b3eSd0jZN0CS"
   },
   "source": [
    "### Tuple are similar to lists but can not be edited after creation similar to string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "jcA-wr0pN0CT",
    "outputId": "f69962fc-fe86-4c3f-8e72-b42053d607b1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2)\n",
      "(1, 2)\n"
     ]
    }
   ],
   "source": [
    "x = (1,2)\n",
    "print(x)\n",
    "x = 1,2\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "DZ7BU_-jN0CT",
    "outputId": "4b3742ee-3416-44f1-d2a9-ed407edf200f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2\n"
     ]
    }
   ],
   "source": [
    "x = (1,2)\n",
    "a, b = x\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "5dZu52ICN0CT",
    "outputId": "45979c43-aa32-4b76-e5fd-4bf4a14e6ee6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2\n",
      "2 1\n"
     ]
    }
   ],
   "source": [
    "x, y = 1, 2\n",
    "print(x, y)\n",
    "x, y = y, x #swapping\n",
    "print(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "YuVEx2dnN0CT",
    "outputId": "6caf5325-5fe7-42d5-d28d-347ced1f27ea"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3] (1, 2, 3)\n",
      "(1, 2, 3) [1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "x = [1, 2, 3]\n",
    "print(x, tuple(x))\n",
    "x = (1,2,3)\n",
    "print(x, list(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "CCTLjPyaN0CU",
    "outputId": "25473e4c-42b3-4eab-c449-d7120f6df19f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x==y = True\n",
      "x is y = True\n"
     ]
    }
   ],
   "source": [
    "x = (1,2,3)\n",
    "y = tuple(x)\n",
    "print('x==y =', x==y)\n",
    "print('x is y =', x is y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "R0sZDSUZN0CU",
    "outputId": "e7258094-830d-4df6-89e3-c586fc54d873"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x==y = True\n",
      "x is y = False\n"
     ]
    }
   ],
   "source": [
    "x = [1,2,3]\n",
    "y = list(x)\n",
    "print('x==y =', x==y)\n",
    "print('x is y =', x is y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "i_Y7edNXN0CU",
    "outputId": "535f8f55-43a2-4952-ec04-ddeaa96dec1c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4, 5, 6, 7)\n"
     ]
    }
   ],
   "source": [
    "x = (1,2,3)\n",
    "y = (4,5,6)\n",
    "print((*x, *y, 7))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vWZNFFdJN0CV"
   },
   "source": [
    "# Sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "nLB-IreDN0CV",
    "outputId": "69b948c3-4d49-4c43-b8e0-278b9293bf2c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set()\n",
      "{1, 2, 3}\n"
     ]
    }
   ],
   "source": [
    "x = set() #empty set\n",
    "print(x)\n",
    "x = {1,2,3}\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "oYknk3GYN0CV",
    "outputId": "a42cfdcd-5536-489d-b398-7b82895d5ddc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3}\n"
     ]
    }
   ],
   "source": [
    "x = [1,2,3,1,2,1]\n",
    "print(set(x)) #sets are unique"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "7eSBcCh3N0CW",
    "outputId": "050e2690-265d-4ba7-9ac9-7a283d2aea08"
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'set' object does not support indexing",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-41-18a224bcd52e>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mx\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m{\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mx\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;31m#error\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'set' object does not support indexing"
     ]
    }
   ],
   "source": [
    "x = {1,2,3}\n",
    "x[0] #error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "MYowNv1cN0CW",
    "outputId": "50ba2f38-21a6-4de3-94fb-511ed60ece4a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "union = {1, 2, 3, 4}\n",
      "intersection = {1}\n",
      "difference = {2, 3}\n"
     ]
    }
   ],
   "source": [
    "x, y = {1,2,3}, {1,4}\n",
    "print('union =', x | y)\n",
    "print('intersection =', x & y)\n",
    "print('difference =', x - y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "mCQauEZEN0CW",
    "outputId": "f6024413-ac48-4ff8-c2d6-b9cf53c39a5c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3}\n",
      "{1, 2, 3}\n",
      "{1, 2, 3, 4}\n",
      "{2, 3, 4}\n",
      "length = 3\n"
     ]
    }
   ],
   "source": [
    "x = {1,2,3}\n",
    "print(x)\n",
    "x.add(1)\n",
    "print(x)\n",
    "x.add(4)\n",
    "print(x)\n",
    "x.remove(1)\n",
    "print(x)\n",
    "print('length =', len(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "2-Gbn0qBN0CX",
    "outputId": "6357e837-107f-43ef-9af1-d55380c9f7d0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x==y = True\n",
      "x is y = False\n"
     ]
    }
   ],
   "source": [
    "x = {1,2,3}\n",
    "y = set(x)\n",
    "print('x==y =', x==y)\n",
    "print('x is y =', x is y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "kRKhWmajN0CX",
    "outputId": "71eb2da0-8e33-44b2-a9fa-984bfcffc3f5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4}\n"
     ]
    }
   ],
   "source": [
    "x = {1, 2, 3}\n",
    "y = {2, 3, 4}\n",
    "print({*x, *y})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "b1nz2vMaN0CX"
   },
   "source": [
    "# Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "EFeJxI2PN0CX",
    "outputId": "9cfd7ebe-6a8b-448c-c230-e45a57a0fec3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{}\n",
      "{}\n",
      "{'a': 1, 2: 'Hello', (1, 2): 'world'}\n"
     ]
    }
   ],
   "source": [
    "x = {} #empty dict\n",
    "print(x)\n",
    "x = dict() #empty dict\n",
    "print(x)\n",
    "x = {'a':1, 2:'Hello', (1,2):'world'}\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "nIP8ZZm2N0CY",
    "outputId": "c09c56ad-a703-49e6-af48-9811043c9939"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "Hello\n",
      "default\n"
     ]
    }
   ],
   "source": [
    "x = {'a':1, 2:'Hello', (1,2):'world'}\n",
    "print(x['a'])\n",
    "print(x[2])\n",
    "print(x.get(1, 'default')) #use default if key doesn't exist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Rpdsee1uN0CY",
    "outputId": "bb2c8913-6e59-4033-d2df-b034ea148a29"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 'String A', 1: 'Integer 1', (1, 2): 'It takes tuples too', None: 'And Nones', False: 'And Booleans'}\n"
     ]
    }
   ],
   "source": [
    "x = {}\n",
    "x['a'] = 'String A'\n",
    "x[1] = 'Integer 1'\n",
    "x[(1,2)] = \"It takes tuples too\"\n",
    "x[None] = 'And Nones'\n",
    "x[False] = 'And Booleans'\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "r_zm35FAN0CY",
    "outputId": "4f521cdc-29b1-4736-a3d8-713591ffdb37"
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unhashable type: 'set'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-1-5252bb27a0fe>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mx\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[1;32m      2\u001b[0m \u001b[0;31m#x[[1,2,3]] = 'No Lists :(' #error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"No Sets :(\"\u001b[0m \u001b[0;31m#error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0;31m#x[x] = 'No Dicts :(' #error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: unhashable type: 'set'"
     ]
    }
   ],
   "source": [
    "x = {}\n",
    "#x[[1,2,3]] = 'No Lists :(' #error\n",
    "x[{1,2,3}] = \"No Sets :(\" #error\n",
    "#x[x] = 'No Dicts :(' #error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "5hdrkPAtN0CZ",
    "outputId": "740203e6-3b97-46d9-a868-610c9f0b4507"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 1, 2: 'Hello', (1, 2): 'world'}\n",
      "{2: 'Hello', (1, 2): 'world'}\n"
     ]
    }
   ],
   "source": [
    "x = {'a':1, 2:'Hello', (1,2):'world'}\n",
    "print(x)\n",
    "del x['a']\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "3ynU9EF0N0CZ",
    "outputId": "eaa14d21-0f9e-45c5-a922-433baa6a3e0d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 'another', 2: 'Hello', (1, 2): 'world', 'b': 100}\n",
      "{'a': 'another', 2: 'Hello', (1, 2): 'world', 'b': 100, 'bye': 10}\n"
     ]
    }
   ],
   "source": [
    "x = {'a':1, 2:'Hello', (1,2):'world'}\n",
    "y = {'a':'another', 'b':100}\n",
    "x.update(**y)\n",
    "print(x)\n",
    "x.update(bye=10)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "oHKJKQMZN0CZ",
    "outputId": "ade92465-0106-4354-e3cb-b6ee3d5bd2bf"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 1, 2: 'Hello', (1, 2): 'world'}\n",
      "['a', 2, (1, 2)]\n",
      "dict_keys(['a', 2, (1, 2)])\n",
      "dict_values([1, 'Hello', 'world'])\n",
      "dict_items([('a', 1), (2, 'Hello'), ((1, 2), 'world')])\n"
     ]
    }
   ],
   "source": [
    "x = [('a',1), (2,'Hello'), ((1,2),'world')]\n",
    "y = dict(x)\n",
    "print(y)\n",
    "print(list(y))\n",
    "print(y.keys())\n",
    "print(y.values())\n",
    "print(y.items())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "O4BmYXA8N0CZ",
    "outputId": "575d3e0f-e068-4606-abc3-e5bfd5096671"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 1, 'b': 6, 'c': 7}\n",
      "{'b': 2, 'c': 9, 'a': 1}\n"
     ]
    }
   ],
   "source": [
    "x = {'a':1, 'b':2}\n",
    "y = {'b':6, 'c':7}\n",
    "print({**x, **y})\n",
    "print({**y, **x, 'c':9})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QxB4aaFmN0Ca"
   },
   "source": [
    "# None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ShkzjeuUN0Ca",
    "outputId": "2a3512a1-b958-4e3e-b6cc-5f593909956f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "x = None\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "wbBDU8B5N0Ca",
    "outputId": "c1f65027-5cfe-4da4-b5a8-d1ad0eaafabf"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "x = None\n",
    "print(x is None)\n",
    "x = 1\n",
    "print(x is None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "PwB0yG0xN0Cb",
    "outputId": "38044908-e9b9-4305-865b-a557ced7b27b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "Something\n"
     ]
    }
   ],
   "source": [
    "x = None\n",
    "print(x or \"Hello\")\n",
    "x = 'Something'\n",
    "print(x or \"Hello\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Ln_gwh-WN0Cb"
   },
   "source": [
    "# IF Conditions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "3TMJ1QV5N0Cb"
   },
   "outputs": [],
   "source": [
    "y = 5\n",
    "if y > 10:\n",
    "    print('y is less than 10')\n",
    "    print('Hello')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "jjNe5HptN0Cb",
    "outputId": "ccc76fdb-cd1b-4dc4-e618-ccdc6315ccbc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y is larger than 10\n"
     ]
    }
   ],
   "source": [
    "y = 15\n",
    "if y < 10:\n",
    "    print('y is less than 10')\n",
    "else:\n",
    "    print('y is larger than 10')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "n1yasPm_N0Cc",
    "outputId": "ef044d80-bc07-49e6-b6e4-2b30a5425c0b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y is less than 20 and larger than 10\n"
     ]
    }
   ],
   "source": [
    "y = 15\n",
    "if y < 10:\n",
    "    print('y is less than 10')\n",
    "elif y < 20:\n",
    "    print('y is less than 20 and larger than 10')\n",
    "else:\n",
    "    print('y is larger than 20')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tTOUnC3RN0Cc"
   },
   "outputs": [],
   "source": [
    "y = 15\n",
    "if y < 10:\n",
    "    print('y is less than 10')\n",
    "elif y < 20:\n",
    "    pass\n",
    "else:\n",
    "    print('y is larger than 20')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "4s0zL78zN0Cc",
    "outputId": "9cc2a70f-8d87-4f30-b168-39b822cf4873"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y is larger than 10\n"
     ]
    }
   ],
   "source": [
    "y = 15\n",
    "print('y is less than 10' if y < 10 else 'y is larger than 10')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Aabi0zZwN0Cc"
   },
   "source": [
    "# While Loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "w87Un0xYN0Cd",
    "outputId": "bea09999-70b2-4b78-e516-28979d02c833"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "4\n",
      "8\n",
      "16\n",
      "32\n",
      "64\n",
      "128\n",
      "256\n",
      "512\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "while i < 1000:\n",
    "    print(i)\n",
    "    i *= 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "_csOk2E7N0Cd",
    "outputId": "e1936842-75da-4058-8809-e178c468a309"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "4\n",
      "8\n",
      "16\n",
      "32\n",
      "64\n",
      "128\n",
      "256\n",
      "512\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "while True:\n",
    "    print(i)\n",
    "    i *= 2\n",
    "    if i >= 1000:\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "3Hp9DqDgN0Cd",
    "outputId": "91127e95-7758-4af9-848f-041468385d91"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i < 10:\n",
    "    i+=1\n",
    "    if i < 5:\n",
    "        continue\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "S9Qkgs3AN0Cd",
    "outputId": "965286f0-116a-4bb6-f33d-03062677d4d1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "You can have an else too by the way\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i < 5:\n",
    "    i+=1\n",
    "    print(i)\n",
    "else:\n",
    "    print('You can have an else too by the way')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "GjaOMQiIN0Ce",
    "outputId": "4288ae23-521a-4773-d40c-fff5e0903f22"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i < 5:\n",
    "    i+=1\n",
    "    print(i)\n",
    "    if i == 4:\n",
    "        break\n",
    "else:\n",
    "    print('You can have an else too by the way')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rn0OZI2DN0Ce"
   },
   "source": [
    "# For loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "A7jd7lciN0Ce",
    "outputId": "d080ac00-1df8-42f8-c0d2-8ecbe412598c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2.5\n",
      "Hello\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "items = [1, 2.5, \"Hello\", True]\n",
    "for item in items:\n",
    "    print(item)\n",
    "#you can use break and continue here too"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "thz283DTN0Ce",
    "outputId": "21c24657-e1bf-4220-8fb1-b2b85d0e0899"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "oPVqz7_SN0Cf",
    "outputId": "0e257ad9-48df-4910-e4bf-7dc6387089e4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range(5,10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "h_XkAo6kN0Cf",
    "outputId": "aa53c3d0-d92b-433d-926b-6c5414f5b7b9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "7\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range(5,10,2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Z2dQ-0gMN0Cg",
    "outputId": "2a9070f9-1ae2-4bcb-f3ca-57fb1479c2b0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "9\n",
      "8\n",
      "7\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "for i in range(10,5,-1):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "iWAtyazHN0Cg",
    "outputId": "28e56393-9de8-4457-e4de-6c5bece92e05",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 a\n",
      "2 b\n",
      "3 c\n"
     ]
    }
   ],
   "source": [
    "for i, j in [(1,'a'), (2,'b'), (3, 'c')]:\n",
    "    print(i, j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ZbAdFzgsN0Cg",
    "outputId": "a3877ad3-cf98-4d69-94dd-44517d3876b2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 : a\n",
      "2 : b\n",
      "3 : c\n"
     ]
    }
   ],
   "source": [
    "d = {1:'a', 2:'b', 3:'c'}\n",
    "for key, value in d.items():\n",
    "    print(key,':',value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "GRDVYGRuN0Ch",
    "outputId": "22969bfa-0e26-4095-9794-1fb08bdb70b3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 : 1\n",
      "1 : 2.5\n",
      "2 : Hello\n",
      "3 : True\n"
     ]
    }
   ],
   "source": [
    "items = [1, 2.5, \"Hello\", True]\n",
    "for index, item in enumerate(items):\n",
    "    print(index,\":\",item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Tpih1OC3N0Ch"
   },
   "source": [
    "# List Comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "mtiSmo_cN0Ch",
    "outputId": "87520717-ecc8-4d22-b363-c73f973f523f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "x = [i for i in range(10)]\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "o-XX8dTSN0Ch",
    "outputId": "a5feeb7b-d206-45c7-edad-49f713601ad2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
     ]
    }
   ],
   "source": [
    "x = [i*i for i in range(10)]\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Y0_EZ6xAN0Ci",
    "outputId": "859f65a7-9916-46af-93ab-49e8385e292f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 4, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "x = [i for i in range(10) if i%2 == 0]\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "9ihLF5LaN0Ci",
    "outputId": "9a8ae2fe-434d-4197-8bca-dba27d0e1e6b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 5.0, 'HelloHello', [3, 4, 3, 4]]\n"
     ]
    }
   ],
   "source": [
    "x = [1,2.5,\"Hello\",[3,4]]\n",
    "y = [i*2 for i in x]\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "PHNrQ3QmN0Ci",
    "outputId": "a8f50ca3-27a8-4213-8396-7ee0a06a637b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[], [0], [0, 1], [0, 1, 2], [0, 1, 2, 3]]\n",
      "[0, 0, 1, 0, 1, 2, 0, 1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "x = [[j for j in range(i)] for i in range(5)]\n",
    "print(x)\n",
    "x = [j for i in range(5) for j in range(i)]\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "sWOwftG9N0Cj",
    "outputId": "21affb2d-e3a8-43b4-a33d-4f5a7e0f574c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
      "[1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "l = [[1,2,3],[4,5,6],[7,8,9]]\n",
    "print(l)\n",
    "print([j for i in l for j in i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "MSGISLECN0Cj",
    "outputId": "fee602e3-5ddd-465d-b4f2-aa0173db13a9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 7, 9]\n"
     ]
    }
   ],
   "source": [
    "a = [1,2,3]\n",
    "b = [4,5,6,7]\n",
    "x = [i+j for i, j in zip(a,b)]\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "hjqFIrlVN0Cj",
    "outputId": "64698368-b0d7-4b22-a2a3-3bd1ff9a32a3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6, 15, 24]\n",
      "[1, 2, 3] [4, 5, 6] [7, 8, 9]\n",
      "[12, 15, 18]\n"
     ]
    }
   ],
   "source": [
    "l = [[1,2,3],[4,5,6],[7,8,9]]\n",
    "x = [sum(i) for i in l]\n",
    "print(x)\n",
    "x = [sum(i) for i in zip(*l)]\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ccCrL9_yN0Cj"
   },
   "source": [
    "# Dictionary Comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "lPjgiTG4N0Ck",
    "outputId": "852cb9d5-d2cd-4343-93a1-b055a992cc0d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 4, 2: 5, 3: 6}\n"
     ]
    }
   ],
   "source": [
    "a = [1,2,3]\n",
    "b = [4,5,6,7]\n",
    "x = {i:j for i, j in zip(a,b)}\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "vkKR26XRN0Ck",
    "outputId": "1570d9b0-7751-4abc-ba39-ba23a69eec7b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 'a', 2: 'b', 3: 'c'}\n"
     ]
    }
   ],
   "source": [
    "d = {'a':1, 'b':2, 'c':3}\n",
    "x = {j:i for i, j in d.items()}\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "dcjF_plSN0Ck",
    "outputId": "88c849ee-5981-462f-a532-ce7fe1bdc031"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0: 0, 1: 1, 4: 2, 9: 3, 16: 4, 25: 5, 36: 6, 49: 7, 64: 8, 81: 9}\n"
     ]
    }
   ],
   "source": [
    "x = {i*i:i for i in range(10)}\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "c3BT7KzMN0Ck"
   },
   "source": [
    "# Set and Tuple Comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "QdxBEbhgN0Cl",
    "outputId": "033f018a-9416-4f4e-bf21-bc5538a92f4f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}\n"
     ]
    }
   ],
   "source": [
    "x = {i for i in range(10)}\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "djnZT4kEN0Cl",
    "outputId": "305debd6-444c-4393-f574-7288f36dfc59"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)\n"
     ]
    }
   ],
   "source": [
    "x = tuple(i for i in range(10))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "iJ6VSBBgN0Cl"
   },
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "a0V6r7Q3N0Cm",
    "outputId": "c427a860-92be-421e-d316-e9b5d14c800f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is Sparta\n"
     ]
    }
   ],
   "source": [
    "def print_this(x):\n",
    "    print(\"This is\", x)\n",
    "\n",
    "print_this(\"Sparta\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "PeBXLiUTN0Cm",
    "outputId": "2b54fee2-c71f-4ff9-b633-8a4bbca05c64"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n"
     ]
    }
   ],
   "source": [
    "def sqr(x):\n",
    "    return x*x\n",
    "\n",
    "print(sqr(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "X6oc-xcON0Cm",
    "outputId": "30657da9-7f5c-455d-bab3-ddeb3effcdd7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000\n",
      "1000\n",
      "1000\n"
     ]
    }
   ],
   "source": [
    "def power(x, n):\n",
    "    return x**n\n",
    "\n",
    "print(power(10,3))\n",
    "print(power(10,n=3))\n",
    "print(power(n=3,x=10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "7OzcrqbZN0Cm",
    "outputId": "d32215c0-c249-4c1d-fd4d-13a3ce061061"
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "positional argument follows keyword argument (<ipython-input-88-862b0f313d03>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-88-862b0f313d03>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    print(power(x=10,3))\u001b[0m\n\u001b[1;37m                    ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m positional argument follows keyword argument\n"
     ]
    }
   ],
   "source": [
    "print(power(x=10,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "aDsstpmeN0Cn",
    "outputId": "d17b83f4-eeeb-484f-c380-561e2bba312d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(16, 2.0)\n"
     ]
    }
   ],
   "source": [
    "def sqr_and_root(x):\n",
    "    return x*x, x**0.5\n",
    "\n",
    "print(sqr_and_root(4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tIrDKIPTN0Cn",
    "outputId": "da1701de-54f6-4327-c052-8244f152489b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "square is 16 and root is 2.0\n",
      "square is 256\n"
     ]
    }
   ],
   "source": [
    "s, r = sqr_and_root(4)\n",
    "print(\"square is\", s, \"and root is\", r)\n",
    "\n",
    "s, _ = sqr_and_root(16) # _ is a valid variable name, usually used to mean don't care\n",
    "print(\"square is\", s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "T6JpLz1VN0Cn",
    "outputId": "627da74b-afdb-4f24-a0a9-8c66bfaeaa45"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(16, 2.0)\n",
      "16\n"
     ]
    }
   ],
   "source": [
    "def sqr_and_root(x):\n",
    "    if x >= 0:\n",
    "        return x*x, x**0.5\n",
    "    else:\n",
    "        return x*x\n",
    "\n",
    "print(sqr_and_root(4))\n",
    "print(sqr_and_root(-4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "DYYiFGPON0Co",
    "outputId": "f8263422-88e0-4b83-e0fb-cdac46f94cfc"
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'int' object is not iterable",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-92-a0190202dbc9>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0ms\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mr\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0msqr_and_root\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m#error\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'int' object is not iterable"
     ]
    }
   ],
   "source": [
    "s, r = sqr_and_root(-4) #error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "smhYu0hfN0Co"
   },
   "outputs": [],
   "source": [
    "def do_nothing():\n",
    "    pass\n",
    "\n",
    "print(do_nothing())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "qmQ3dALzN0Cp"
   },
   "outputs": [],
   "source": [
    "def prod(x,y):\n",
    "    return x*y\n",
    "\n",
    "print(prod(3,4))\n",
    "\n",
    "def prod(x,y,z):\n",
    "    return x*y*z\n",
    "\n",
    "print(prod(3,4,5))\n",
    "print(prod(3,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "27pZ6qfvN0Cp",
    "outputId": "89cad750-0a7b-4e96-b00f-a25d07fe666d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "60\n",
      "12\n"
     ]
    }
   ],
   "source": [
    "def prod(x,y,z=1):\n",
    "    return x*y*z\n",
    "\n",
    "print(prod(3,4,5))\n",
    "print(prod(3,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "CcDiK3npN0Cp",
    "outputId": "9cab3f1a-d43f-4b0f-e927-0abe4b551c6d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "60\n",
      "12\n",
      "3\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "def prod(*l):\n",
    "    p = 1\n",
    "    for i in l:\n",
    "        p *= i\n",
    "    return p\n",
    "\n",
    "print(prod(3,4,5))\n",
    "print(prod(3,4))\n",
    "print(prod(3))\n",
    "print(prod())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "jIK_e8VVN0Cp",
    "outputId": "69b26770-35f7-4103-cbfe-a8c99b486fcc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "def prod(x,y,z=1):\n",
    "    return x*y*z\n",
    "\n",
    "l = [1,2,3]\n",
    "print(prod(*l))\n",
    "\n",
    "def prod(*l):\n",
    "    p = 1\n",
    "    for i in l:\n",
    "        p *= i\n",
    "    return p\n",
    "\n",
    "l = [1,2,3]\n",
    "print(prod(*l))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "kI4w9L_-N0Cq",
    "outputId": "aecf49fe-018d-47d0-e447-ac7f357b2e5d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000\n"
     ]
    }
   ],
   "source": [
    "def power(x, n):\n",
    "    return x**n\n",
    "\n",
    "d = {'x':10, 'n': 3}\n",
    "print(power(**d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "XUTzBmOiN0Cq",
    "outputId": "29b69535-f361-482e-e7ff-82d114a99080"
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "power() missing 1 required positional argument: 'n'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-97-635d86f9e360>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0md\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m{\u001b[0m\u001b[1;34m'x'\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpower\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m**\u001b[0m\u001b[0md\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: power() missing 1 required positional argument: 'n'"
     ]
    }
   ],
   "source": [
    "d = {'x':10}\n",
    "print(power(**d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "n6j1HUDyN0Cr",
    "outputId": "ea756fa9-93f8-4348-a5ac-550f35910d44"
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "power() got an unexpected keyword argument 'a'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-98-daf6aa71c371>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0md\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m{\u001b[0m\u001b[1;34m'x'\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'n'\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'a'\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpower\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m**\u001b[0m\u001b[0md\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: power() got an unexpected keyword argument 'a'"
     ]
    }
   ],
   "source": [
    "d = {'x':10, 'n':3, 'a':4}\n",
    "print(power(**d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "hFKm5PpJN0Cr",
    "outputId": "db1ebab9-4798-4147-8bfb-e98b0bd741e2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "60\n",
      "12\n"
     ]
    }
   ],
   "source": [
    "def prod(x,y,z=1):\n",
    "    return x*y*z\n",
    "\n",
    "d = {'x':3, 'y':4, 'z':5}\n",
    "print(prod(**d))\n",
    "\n",
    "d = {'x':3, 'y':4}\n",
    "print(prod(**d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "jIsTGFmlN0Cr",
    "outputId": "5d5db225-cce2-477b-ef6d-e4d6bc2a61fd"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I received 3 elements\n",
      "They are {'hello': 1, 'bye': 'world', 'x': True}\n"
     ]
    }
   ],
   "source": [
    "def misc(**k):\n",
    "    print('I received %i elements' % len(k))\n",
    "    print('They are', k)\n",
    "\n",
    "misc(hello=1, bye='world', x=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "kwSHmIW5N0Cr",
    "outputId": "b0e04c70-4fea-4dc5-abe4-7de72bd66288"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 ['hello']\n"
     ]
    }
   ],
   "source": [
    "def do_changes(x,l):\n",
    "    x += 1\n",
    "    l.append('hello')\n",
    "\n",
    "x, l = 0, []\n",
    "do_changes(x,l)\n",
    "print(x, l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "FGe1r7-dN0Cs",
    "outputId": "5937ac65-640b-44cb-d66d-e1568e777d51"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 []\n"
     ]
    }
   ],
   "source": [
    "def do_changes(x,l):\n",
    "    x += 1\n",
    "    l = l + ['hello']\n",
    "\n",
    "x, l = 0, []\n",
    "do_changes(x,l)\n",
    "print(x, l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "-2IbHY2MN0Cs",
    "outputId": "c28b4cc8-bfff-4437-97bf-e10c2d5f463e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n",
      "14\n"
     ]
    }
   ],
   "source": [
    "def dbl(x):\n",
    "    return x*2\n",
    "\n",
    "def sqr(x):\n",
    "    return x*x\n",
    "\n",
    "def apply_and_sum(l, fn):\n",
    "    return sum(fn(i) for i in l)\n",
    "\n",
    "print(apply_and_sum([1,2,3], dbl))\n",
    "print(apply_and_sum([1,2,3], sqr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "sODjHx58N0Cs",
    "outputId": "ec05f90b-e651-49ff-b72f-6a750f8a68a5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n",
      "14\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "dbl = lambda x: x*2\n",
    "sqr = lambda x: x*x\n",
    "\n",
    "def apply_and_sum(l, fn = lambda x: x):\n",
    "    return sum(fn(i) for i in l)\n",
    "\n",
    "print(apply_and_sum([1,2,3], dbl))\n",
    "print(apply_and_sum([1,2,3], sqr))\n",
    "print(apply_and_sum([1,2,3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "SXcXB28sN0Ct",
    "outputId": "fbbb67e8-aec1-4422-dc87-996e45c0c5fb"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "11\n"
     ]
    }
   ],
   "source": [
    "no_param = lambda:5\n",
    "print(no_param())\n",
    "\n",
    "two_param = lambda x,y:x+y\n",
    "print(two_param(5, 6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5SJwWuR4N0Ct"
   },
   "source": [
    "# Variable Scope"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "_XpT09rHN0Cu",
    "outputId": "7f0465d4-07e9-4e0f-a478-f05431491921"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "hello 2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "def hello():\n",
    "    x = 2\n",
    "    print(\"hello\", x)\n",
    "\n",
    "x=1\n",
    "print(x)\n",
    "hello()\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "2ZQVhYQNN0Cu",
    "outputId": "3787fb5c-c7a6-47af-b49f-7a88077f882b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "global 1\n",
      "hello 2\n",
      "global 2\n"
     ]
    }
   ],
   "source": [
    "def hello():\n",
    "    global x\n",
    "    x = 2\n",
    "    print(\"hello\", x)\n",
    "\n",
    "x=1\n",
    "print(\"global\", x)\n",
    "hello()\n",
    "print(\"global\", x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "LJ1_8Qv5N0Cu",
    "outputId": "71939f25-8571-44c2-f4fd-6a9430a9cfe7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "global 1\n",
      "hello 2\n",
      "bye 3\n",
      "hello 2\n",
      "global 1\n"
     ]
    }
   ],
   "source": [
    "def hello():\n",
    "    x = 2\n",
    "    \n",
    "    def bye():\n",
    "        x = 3\n",
    "        print(\"bye\", x)\n",
    "    \n",
    "    print(\"hello\", x)\n",
    "    bye()\n",
    "    print(\"hello\", x)\n",
    "    \n",
    "\n",
    "x=1\n",
    "print(\"global\", x)\n",
    "hello()\n",
    "print(\"global\", x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "rLLU7zemN0Cv",
    "outputId": "a5ddbec8-87c0-4fbc-e561-c66967004a30"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "global 1\n",
      "hello 2\n",
      "bye 3\n",
      "hello 2\n",
      "global 3\n"
     ]
    }
   ],
   "source": [
    "def hello():\n",
    "    x = 2\n",
    "    \n",
    "    def bye():\n",
    "        global x\n",
    "        x = 3\n",
    "        print(\"bye\", x)\n",
    "    \n",
    "    print(\"hello\", x)\n",
    "    bye()\n",
    "    print(\"hello\", x)\n",
    "    \n",
    "\n",
    "x=1\n",
    "print(\"global\", x)\n",
    "hello()\n",
    "print(\"global\", x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "uTY03H-HN0Cv",
    "outputId": "00cf0984-d1e2-4649-b127-7b1f700b6a1e"
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'function' object has no attribute 'bye'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-3-fbbf4e78dbbc>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     11\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"hello\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 13\u001b[0;31m \u001b[0mhello\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbye\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[1;32m     14\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     15\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"global\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'function' object has no attribute 'bye'"
     ]
    }
   ],
   "source": [
    "def hello():\n",
    "    x = 2\n",
    "    \n",
    "    def bye():\n",
    "        nonlocal x\n",
    "        x = 3\n",
    "        print(\"bye\", x)\n",
    "    \n",
    "    print(\"hello\", x)\n",
    "    bye()\n",
    "    print(\"hello\", x)\n",
    "    \n",
    "\n",
    "x=1\n",
    "print(\"global\", x)\n",
    "hello()\n",
    "print(\"global\", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wiAnl7qiN0Cw"
   },
   "source": [
    "### Note: you can read a variable from an outer scope with global or nonloacal. They are only neccessary for variable assignment."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4reiU7hQN0Cw"
   },
   "source": [
    "# Common Mistakes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "UaGx3Nk4N0Cw",
    "outputId": "8b1fe0b1-d4f4-442c-f4ee-eaab568f1b75"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hello', 8, 4, 2, 1]\n",
      "[8, 4, 2, 1]\n",
      "[8, 4, 2, 1, 8, 4, 2, 1]\n",
      "[8, 4, 2, 1, 8, 4, 2, 1, 8, 4, 2, 1]\n",
      "[8, 4, 2, 1]\n",
      "[8, 4, 2, 1, 8, 4, 2, 1, 8, 4, 2, 1, 8, 4, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "def addSeq(n, l=[]):\n",
    "    while n != 0:\n",
    "        l.append(n)\n",
    "        n //= 2\n",
    "    return l\n",
    "\n",
    "print(addSeq(8, ['Hello']))\n",
    "print(addSeq(8))\n",
    "print(addSeq(8))\n",
    "print(addSeq(8))\n",
    "print(addSeq(8,[]))\n",
    "print(addSeq(8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "-pbnxTlTN0Cw",
    "outputId": "90f07900-763d-485c-86e9-7592de65342f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hello', 8, 4, 2, 1]\n",
      "[8, 4, 2, 1]\n",
      "[8, 4, 2, 1]\n",
      "[8, 4, 2, 1]\n",
      "[8, 4, 2, 1]\n",
      "[8, 4, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "def addSeq(n, l=None):\n",
    "    l = l or []\n",
    "    while n != 0:\n",
    "        l.append(n)\n",
    "        n //= 2\n",
    "    return l\n",
    "\n",
    "print(addSeq(8, ['Hello']))\n",
    "print(addSeq(8))\n",
    "print(addSeq(8))\n",
    "print(addSeq(8))\n",
    "print(addSeq(8,[]))\n",
    "print(addSeq(8))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aQskQqPvN0Cx"
   },
   "source": [
    "# Importing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "yC7fEaP2N0Cy"
   },
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "#jupyter magic to reload package the have been changed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "DqgTcmtLN0Cy"
   },
   "outputs": [],
   "source": [
    "import math\n",
    "from math import sqrt\n",
    "from math import*\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pf4C5ZNiN0C0"
   },
   "source": [
    "# Read and Write Files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "id": "O96XGIB1N0C0"
   },
   "outputs": [],
   "source": [
    "f = open('new.txt','w')\n",
    "f.write('hello')\n",
    "f.close() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "RX5qy80XN0C0",
    "outputId": "107eb0be-4e7b-4738-fbc3-19ac1863f919"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "f = open('new.txt','r')\n",
    "s = f.read()\n",
    "f.close()\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "McYELn21N0C3"
   },
   "source": [
    "# Classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "eK4WjNRqN0C3",
    "outputId": "e82eb1ef-a29d-4623-c733-a20b1cafe32b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is <Unknown>, I am 20 years old\n",
      "My name is Mohamed, I am 50 years old\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self, name=\"<Unknown>\", age=20):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "    \n",
    "    def introduce(self):\n",
    "        print(\"My name is %s, I am %i years old\" % (self.name, self.age))\n",
    "    \n",
    "p = Person()\n",
    "p.introduce()\n",
    "p.name = \"Mohamed\"\n",
    "p.age = 50\n",
    "p.introduce()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "1Io5KDmAN0C3",
    "outputId": "659ed2d4-34db-431f-8d13-93a0dfb96589"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 , 2\n",
      "1 , 2\n"
     ]
    }
   ],
   "source": [
    "class EmptyObject:\n",
    "    def __init__(self):\n",
    "        pass\n",
    "\n",
    "o = EmptyObject()\n",
    "o.x = 1\n",
    "o.y = 2\n",
    "print(o.x, ',', o.y)\n",
    "\n",
    "def display(self):\n",
    "    print(self.x, ',', self.y)\n",
    "\n",
    "EmptyObject.show = display\n",
    "o.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "_yumeoNLN0C4",
    "outputId": "6d608ac6-cdcb-4a7f-a935-abbf1d06e70a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is Mohamed, I was born in 1989\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "\n",
    "class Person:\n",
    "    def __init__(self, name=\"<Unknown>\", age=20):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "    \n",
    "    def getBirthYear(self):\n",
    "        return datetime.date.today().year - self.age\n",
    "    \n",
    "    def introduce(self):\n",
    "        print(\"My name is %s, I was born in %i\" % (self.name, self.getBirthYear()))\n",
    "\n",
    "p = Person(\"Mohamed\", 30)\n",
    "p.introduce()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "PHuM_Tk7N0C4",
    "outputId": "a1c98ac9-569b-45e7-84e6-459d31bb7019"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RIP Ahmed\n",
      "My name is Mohamed, I was born in 1991\n",
      "RIP Mohamed\n",
      "My name is Ahmed, I was born in 2001\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "\n",
    "class Person:\n",
    "    def __init__(self, name=\"<Unknown>\", age=20):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "    \n",
    "    def getBirthYear(self):\n",
    "        return datetime.date.today().year - self.age\n",
    "    \n",
    "    def introduce(self):\n",
    "        print(\"My name is %s, I was born in %i\" % (self.name, self.getBirthYear()))\n",
    "    \n",
    "    def __del__(self):\n",
    "        print(\"RIP\", self.name)\n",
    "    def __add__(self,new_age):\n",
    "        self.age-=new_age\n",
    "\n",
    "p = Person(\"Mohamed\", 30)\n",
    "p.introduce()\n",
    "p = Person(\"Ahmed\", 20)\n",
    "p.introduce()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "id": "-4exTeJcN0C4",
    "outputId": "068c947c-8284-45cf-9630-3097aa33b118"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is Ahmed, I was born in 2001\n",
      "My name is Ahmed, I was born in 2006\n"
     ]
    }
   ],
   "source": [
    "#del p\n",
    "p.introduce()\n",
    "p+5\n",
    "p.introduce()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Fl53aBVfN0C4",
    "outputId": "69913bf3-ba54-4070-8715-570e23fd4f8e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is Mohamed, I was born in 1991\n",
      "Population = 1\n",
      "RIP Mohamed\n",
      "My name is Ahmed, I was born in 2001\n",
      "Population = 1\n",
      "My name is Samir, I was born in 1981\n",
      "Population = 2\n",
      "RIP Ahmed\n",
      "RIP Samir\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "\n",
    "class Person:\n",
    "    \n",
    "    population = 0\n",
    "    \n",
    "    def __init__(self, name=\"<Unknown>\", age=20):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        Person.population += 1\n",
    "    \n",
    "    def getBirthYear(self):\n",
    "        return datetime.date.today().year - self.age\n",
    "    \n",
    "    def introduce(self):\n",
    "        print(\"My name is %s, I was born in %i\" % (self.name, self.getBirthYear()))\n",
    "    \n",
    "    def __del__(self):\n",
    "        print(\"RIP\", self.name)\n",
    "        Person.population -= 1\n",
    "\n",
    "p = Person(\"Mohamed\", 30)\n",
    "p.introduce()\n",
    "print(\"Population =\", Person.population)\n",
    "\n",
    "p = Person(\"Ahmed\", 20)\n",
    "p.introduce()\n",
    "print(\"Population =\", Person.population)\n",
    "\n",
    "p2 = Person(\"Samir\", 40)\n",
    "p2.introduce()\n",
    "print(\"Population =\", Person.population)\n",
    "\n",
    "del p\n",
    "del p2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "gRP0cMNTN0C5",
    "outputId": "37f1d460-a691-497c-df24-2e1b5e6ae9e2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is Mohamed, I was born in 1989\n",
      "The are 1 person(s)\n",
      "RIP Mohamed\n",
      "My name is Ahmed, I was born in 1999\n",
      "The are 1 person(s)\n",
      "My name is Samir, I was born in 1979\n",
      "The are 2 person(s)\n",
      "RIP Ahmed\n",
      "RIP Samir\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "\n",
    "class Person:\n",
    "    \n",
    "    population = 0\n",
    "    \n",
    "    def __init__(self, name=\"<Unknown>\", age=20):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        Person.population += 1\n",
    "    \n",
    "    def getBirthYear(self):\n",
    "        return datetime.date.today().year - self.age\n",
    "    \n",
    "    def introduce(self):\n",
    "        print(\"My name is %s, I was born in %i\" % (self.name, self.getBirthYear()))\n",
    "    \n",
    "    def __del__(self):\n",
    "        print(\"RIP\", self.name)\n",
    "        Person.population -= 1\n",
    "    \n",
    "    @staticmethod\n",
    "    def displayPopulation():\n",
    "        print(\"The are %i person(s)\" % Person.population)\n",
    "\n",
    "p = Person(\"Mohamed\", 30)\n",
    "p.introduce()\n",
    "Person.displayPopulation()\n",
    "\n",
    "p = Person(\"Ahmed\", 20)\n",
    "p.introduce()\n",
    "Person.displayPopulation()\n",
    "\n",
    "p2 = Person(\"Samir\", 40)\n",
    "p2.introduce()\n",
    "Person.displayPopulation()\n",
    "\n",
    "del p\n",
    "del p2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ssQCSFMIN0C5"
   },
   "source": [
    "# Inheritence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Nn1seR-jN0C5",
    "outputId": "f5a02b0b-f478-4fd2-bed2-9bfc338744c4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is Mohamed, I was born in 1989\n",
      "My name is Ramy, I was born in 2009, I study at Future Schools\n",
      "My name is Hoda, I was born in 1979, I work at Future Tech Co.\n",
      "\n",
      "is p1 a Person? True\n",
      "is p1 a Student? False\n",
      "is p1 a Employee? False\n",
      "\n",
      "is p2 a Person? True\n",
      "is p2 a Student? True\n",
      "is p2 a Employee? False\n",
      "\n",
      "is p3 a Person? True\n",
      "is p3 a Student? False\n",
      "is p3 a Employee? True\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "\n",
    "class Person:\n",
    "    def __init__(self, name=\"<Unknown>\", age=20):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "    \n",
    "    def getBirthYear(self):\n",
    "        return datetime.date.today().year - self.age\n",
    "    \n",
    "    def introduce(self):\n",
    "        print(\"My name is %s, I was born in %i\" % (self.name, self.getBirthYear()))\n",
    "\n",
    "class Student(Person):\n",
    "    def __init__(self, name=\"<Unknown>\", age=20, school=\"<Unknown>\"):\n",
    "        super().__init__(name, age)\n",
    "        self.school = school\n",
    "    \n",
    "    def introduce(self):\n",
    "        print(\"My name is %s, I was born in %i, I study at %s\" % (self.name, self.getBirthYear(), self.school))\n",
    "\n",
    "class Employee(Person):\n",
    "    def __init__(self, name=\"<Unknown>\", age=20, company=\"<Unknown>\"):\n",
    "        super().__init__(name, age)\n",
    "        self.company = company\n",
    "    \n",
    "    def introduce(self):\n",
    "        print(\"My name is %s, I was born in %i, I work at %s\" % (self.name, self.getBirthYear(), self.company))\n",
    "\n",
    "p1 = Person(\"Mohamed\", 30)\n",
    "p1.introduce()\n",
    "\n",
    "p2 = Student(\"Ramy\", 10, \"Future Schools\")\n",
    "p2.introduce()\n",
    "\n",
    "p3 = Employee(\"Hoda\", 40, \"Future Tech Co.\")\n",
    "p3.introduce()\n",
    "\n",
    "print()\n",
    "print(\"is p1 a Person?\", isinstance(p1, Person))\n",
    "print(\"is p1 a Student?\", isinstance(p1, Student))\n",
    "print(\"is p1 a Employee?\", isinstance(p1, Employee))\n",
    "\n",
    "print()\n",
    "print(\"is p2 a Person?\", isinstance(p2, Person))\n",
    "print(\"is p2 a Student?\", isinstance(p2, Student))\n",
    "print(\"is p2 a Employee?\", isinstance(p2, Employee))\n",
    "\n",
    "\n",
    "print()\n",
    "print(\"is p3 a Person?\", isinstance(p3, Person))\n",
    "print(\"is p3 a Student?\", isinstance(p3, Student))\n",
    "print(\"is p3 a Employee?\", isinstance(p3, Employee))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XBM5p_fQN0C6"
   },
   "source": [
    "# Operator Overloading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "TAhZE00WN0C6",
    "outputId": "dc54326a-84d8-45d6-8c43-3a468eb744b6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1.100000,2.200000) + (0.900000,0.800000) = (2.000000,3.000000)\n"
     ]
    }
   ],
   "source": [
    "class Vector2:\n",
    "    def __init__(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "    \n",
    "    def __str__(self):\n",
    "        return \"(%f,%f)\" % (self.x, self.y)\n",
    "    \n",
    "    def __add__(self, other):\n",
    "        return Vector2(self.x + other.x, self.y + other.y)\n",
    "    \n",
    "v1 = Vector2(1.1, 2.2)\n",
    "v2 = Vector2(0.9, 0.8)\n",
    "print(v1, '+', v2, '=', v1+v2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JwbqvjcKN0C6"
   },
   "source": [
    "# Exceptions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "tQF8a7i7N0C6",
    "outputId": "5e67ead0-7af6-4359-9846-47049649ce87"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "An exception was caught\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    x = undefined_variable\n",
    "except:\n",
    "    print(\"An exception was caught\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Wxhied79N0C7",
    "outputId": "b525b22f-0aba-4ce1-9221-72a153e9c54f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.0\n",
      "No errors happened\n",
      "This will run anyway\n",
      "Can't Divide by Zero\n",
      "This will run anyway\n",
      "unsupported operand type(s) for /: 'str' and 'int'\n",
      "This will run anyway\n"
     ]
    }
   ],
   "source": [
    "def div(x,y):\n",
    "    try:\n",
    "        print(x/y)\n",
    "    except ZeroDivisionError:\n",
    "        print(\"Can't Divide by Zero\")\n",
    "    except Exception as e:\n",
    "        print(e)\n",
    "    else:\n",
    "        print(\"No errors happened\")\n",
    "    finally:\n",
    "        print(\"This will run anyway\")\n",
    "\n",
    "div(10,2)\n",
    "div(10,0)\n",
    "div(\"Hello\",2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "yQvq95T9N0C7",
    "outputId": "01b93fd5-14a6-414f-f242-12b4dc240d64"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorry, I do positive div only\n",
      "This will run anyway\n"
     ]
    }
   ],
   "source": [
    "def div(x,y):\n",
    "    try:\n",
    "        assert x >= 0, \"Sorry, I do positive div only\"\n",
    "        print(x/y)\n",
    "    except ZeroDivisionError:\n",
    "        print(\"Can't Divide by Zero\")\n",
    "    except Exception as e:\n",
    "        print(e)\n",
    "    else:\n",
    "        print(\"No errors happened\")\n",
    "    finally:\n",
    "        print(\"This will run anyway\")\n",
    "\n",
    "div(-10,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "izHa4jiFN0C7",
    "outputId": "6c583254-f001-44f3-959b-057b52ced7c7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorry, I do positive div only\n",
      "This will run anyway\n"
     ]
    }
   ],
   "source": [
    "class CustomException(Exception):\n",
    "    pass\n",
    "\n",
    "def div(x,y):\n",
    "    try:\n",
    "        if x < 0:\n",
    "            raise CustomException()\n",
    "        print(x/y)\n",
    "    except ZeroDivisionError:\n",
    "        print(\"Can't Divide by Zero\")\n",
    "    except CustomException as e:\n",
    "        print(\"Sorry, I do positive div only\")\n",
    "    except Exception as e:\n",
    "        print(e)\n",
    "    else:\n",
    "        print(\"No errors happened\")\n",
    "    finally:\n",
    "        print(\"This will run anyway\")\n",
    "\n",
    "div(-10,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xZUUWBWNN0C8"
   },
   "source": [
    "# Generators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "2e4yWLX5N0C8",
    "outputId": "3ca17f2c-e778-4c64-e256-440dc8e14733"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "range(0, 10)\n",
      "<range_iterator object at 0x7fa1df316f30>\n"
     ]
    }
   ],
   "source": [
    "x = range(10)\n",
    "print(x)\n",
    "it = iter(x)\n",
    "print(it)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "iwIlnsdrN0C9",
    "outputId": "64f0d23e-e4c2-461c-e124-6a041b16ab18",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(next(it))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "seIkR7EnN0C9",
    "outputId": "13a1116e-e038-4983-ed3e-83b3887b9e39"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5, 7, 11, 13, 17, 19, 23]\n",
      "<list_iterator object at 0x000001D5D63BA7B8>\n"
     ]
    }
   ],
   "source": [
    "x = [2,3,5,7,11,13,17,19,23]\n",
    "print(x)\n",
    "it = iter(x)\n",
    "print(it)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "LVaK2d-VN0C9",
    "outputId": "38153df6-7969-49ba-a12d-a722ae593eae",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "print(next(it))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "DFCv8N7LN0C-",
    "outputId": "5cea95af-c81d-4576-f6d0-372334a60d21"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<generator object <genexpr> at 0x7fa1df318bd0>\n"
     ]
    }
   ],
   "source": [
    "it = (i*i for i in range(10))\n",
    "print(it)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "UV5fd-cpN0C-",
    "outputId": "72b9a2c3-3c77-4ef7-dc89-f55eeea59d72",
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "print(next(it))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "GT3lDbn0N0DA",
    "outputId": "da222cfc-ae00-44ec-9ed0-53a84b33bb68",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 6, 10, 15, 21, 28, 36, 45]\n",
      "[1, 3, 6, 10, 15, 21, 28, 36, 45]\n"
     ]
    }
   ],
   "source": [
    "def cumsum(it):\n",
    "    s = 0\n",
    "    for i in it:\n",
    "        s += i\n",
    "        yield s\n",
    "\n",
    "a = [1,2,3,4,5,6,7,8,9]\n",
    "print([i for i in cumsum(a)])\n",
    "print(list(cumsum(a)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kVktL0YWN0DB"
   },
   "source": [
    "# Context"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "CpFSSMZRN0DB",
    "outputId": "1c6cfc20-3dd4-4e3c-de15-5b6a67fdce10"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entering\n",
      "Hello World\n",
      "Exiting\n"
     ]
    }
   ],
   "source": [
    "class Context:\n",
    "    def __enter__(self):\n",
    "        print(\"Entering\")\n",
    "    \n",
    "    def __exit__(self, exc_type, exc_value, traceback):\n",
    "        print(\"Exiting\")\n",
    "\n",
    "with Context():\n",
    "    print(\"Hello World\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "s1yRUG6_N0DC",
    "outputId": "5fdc5ba6-51fd-429e-df1d-a64390af801c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start Counting...\n",
      "Hello World\n",
      "Good Bye\n",
      "Real Good Bye\n",
      "Function called 3 time(s)\n"
     ]
    }
   ],
   "source": [
    "class CountedFunction:\n",
    "    def __init__(self, fn):\n",
    "        self.fn = fn\n",
    "        self.count = 0\n",
    "    \n",
    "    def __call__(self, *args, **kwargs):\n",
    "        self.count += 1\n",
    "        return self.fn(*args, **kwargs)\n",
    "    \n",
    "    def __enter__(self):\n",
    "        print(\"Start Counting...\")\n",
    "        self.count = 0\n",
    "        return self\n",
    "    \n",
    "    def __exit__(self, exc_type, exc_value, traceback):\n",
    "        print(f'Function called {self.count} time(s)')\n",
    "\n",
    "with CountedFunction(print) as p:\n",
    "    p(\"Hello World\")\n",
    "    p(\"Good Bye\")\n",
    "    p(\"Real Good Bye\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ijxx0ig3N0DD"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "name": "Intro to python",
   "provenance": [],
   "toc_visible": true
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}