basics.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "4d1eb812-1b4e-49ef-b62a-8d7aadc5b0cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "def outOfRut():\n",
    "    age = int(input('How old are you? '))                      \n",
    "    if age >= 13 and age <= 19:                             \n",
    "        print('So, you\\'re a teen, huh? You\\'re already %s!' % age)\n",
    "    else:\n",
    "        print('Huh?')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e3e7ab1a-22aa-45b2-9ab7-354f7b14099c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "How old are you? 18\n",
      "So, you're a teen, huh? You're already 18!\n"
     ]
    }
   ],
   "source": [
    "outOfRut()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1b87f8d",
   "metadata": {},
   "source": [
    "# Classes and Objects\n",
    "## Classes\n",
    "We have learnt about Classifications in P3. Did you know that they can also be applied in the Python world?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "964f1009",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Things:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4868110d",
   "metadata": {},
   "source": [
    "We created the class Things first as it is the broadest. pass is used to tell Python that that is all the information we will provide. pass is used when we want to provide a class or function but don’t want to fill in the details at the moment.\n",
    "### Families\n",
    "If a class is part of another class, it is a child of the other class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "feefb588",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Inanimate(Things):\n",
    "    pass\n",
    "class Animate(Things):\n",
    "    pass\n",
    "class Animals(Animate):\n",
    "    pass\n",
    "class Plants(Animate):\n",
    "    pass\n",
    "class Bacteria(Animate):\n",
    "    pass\n",
    "class Fungi(Animate):\n",
    "    pass\n",
    "class OnceAlive(Inanimate):\n",
    "    pass\n",
    "class NeverAlive(Animate):\n",
    "    pass\n",
    "class Mammals(Animals):\n",
    "    pass\n",
    "class Humans(Mammals):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37c7dbd2",
   "metadata": {},
   "source": [
    "Here, Inanimate and Animate are children of Things. The parent is Things, which is wrapped up in round brackets.\n",
    "## Objects\n",
    "Here is how to make an object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "73de6ddb",
   "metadata": {},
   "outputs": [],
   "source": [
    "mashrafi = Humans()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1e9dcd7",
   "metadata": {},
   "source": [
    "Here, mashrafi becomes a variable. \n",
    "### Using Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b9b1d91a",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Animals(Animate):\n",
    "    def breathe(self):\n",
    "        print('Breathing...')\n",
    "    def move(self):\n",
    "        print('Moving...')\n",
    "    def eat(self):\n",
    "        print('Eating...')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "0abf7d9b",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Humans' object has no attribute 'eat'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/tf/0c8w0zdx03xg0xwmsj1rs6b00000gq/T/ipykernel_13954/2157882152.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmashrafi\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0meat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'Humans' object has no attribute 'eat'"
     ]
    }
   ],
   "source": [
    "mashrafi.eat()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97afcd21",
   "metadata": {},
   "source": [
    "As you can see here, mashrafi inherited functions from the Animal class. \n",
    "### A More Graphical Approach (to understanding the Pros of Classes and Objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0953578",
   "metadata": {},
   "outputs": [],
   "source": [
    "import turtle\n",
    "ma = turtle.Pen()\n",
    "me = turtle.Pen()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f7d58848",
   "metadata": {},
   "outputs": [],
   "source": [
    "ma.forward(50)\n",
    "ma.right(90)\n",
    "ma.forward(20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d789cfdb",
   "metadata": {},
   "outputs": [],
   "source": [
    "me.left(90)\n",
    "me.forward(100)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71ed8075",
   "metadata": {},
   "source": [
    "Try this out for yourself and you'd be amazed that there are two pointers! That isn't really the point. Instead, this is really similar to Classes and Objects.\n",
    "### Functions Inside Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "19f9d360",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moving...\n",
      "There's food here!\n",
      "Eating...\n"
     ]
    }
   ],
   "source": [
    "class Mammals:\n",
    "    pass\n",
    "class Humans(Mammals):\n",
    "    def move(self):\n",
    "        print('Moving...')\n",
    "    def eat(self):\n",
    "        print('Eating...')\n",
    "    def apocalypticShopping(self):\n",
    "        self.move()\n",
    "        print('There\\'s food here!')\n",
    "        self.eat()\n",
    "mashrafi = Humans()\n",
    "mashrafi.apocalypticShopping()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "609ce1c9",
   "metadata": {},
   "source": [
    "The self parameter is a way for one function in the class to call another function in the class (and in the parent class). So, you can get this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d1c263ae",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moving...\n",
      "There's food here!\n",
      "Eating...\n"
     ]
    }
   ],
   "source": [
    "class Mammals:\n",
    "    def move(self):\n",
    "        print('Moving...')\n",
    "    def eat(self):\n",
    "        print('Eating...')\n",
    "    def apocalypticShopping(self):\n",
    "        self.move()\n",
    "        print('There\\'s food here!')\n",
    "        self.eat()\n",
    "Mammals().apocalypticShopping()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7da21c53",
   "metadata": {},
   "source": [
    "But not this: (because parents cannot inherit functions from children)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e55e79d1",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Animals' object has no attribute 'apocalypticShopping'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/tf/0c8w0zdx03xg0xwmsj1rs6b00000gq/T/ipykernel_22981/3320425750.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     10\u001b[0m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'There\\'s food here!'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0meat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 12\u001b[0;31m \u001b[0mAnimals\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mapocalypticShopping\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'Animals' object has no attribute 'apocalypticShopping'"
     ]
    }
   ],
   "source": [
    "class Animals:\n",
    "    pass\n",
    "class Mammals(Animals):\n",
    "    def move(self):\n",
    "        print('Moving...')\n",
    "    def eat(self):\n",
    "        print('Eating...')\n",
    "    def apocalypticShopping(self):\n",
    "        self.move()\n",
    "        print('There\\'s food here!')\n",
    "        self.eat()\n",
    "Animals().apocalypticShopping()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0874cb23-c7de-4134-970c-d7940be82f3e",
   "metadata": {},
   "source": [
    "## Initialising Objects\n",
    "to prepare them for the real world using the __init__ function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "95e518a1-af72-4f46-bb8b-10e18fab0aac",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Humans:\n",
    "        def __init__(self, spots):\n",
    "            self.spots = spots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "9f7e2bc9-982f-4f24-ba08-a2017f3f0dfa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "marsh = Humans(20)\n",
    "sharm = Humans(0)\n",
    "print(marsh.spots)\n",
    "print(sharm.spots)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9e0e368-b4e4-46af-851d-ae6cc9332255",
   "metadata": {},
   "source": [
    "Remember, when we create an object of a class, such as ozwald above, we can refer to its variables or functions using the dot opera- tor and the name of the variable or function we want to use.\n",
    "#### Challenge 2: Turtle Pitchfork"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "2a33f26a-11d8-4a88-879f-5b9047744920",
   "metadata": {},
   "outputs": [],
   "source": [
    "import turtle\n",
    "a = turtle.Pen()\n",
    "b = turtle.Pen()\n",
    "c = turtle.Pen()\n",
    "d = turtle.Pen()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a9100601-772a-4d96-8708-bb8755a57c7b",
   "metadata": {},
   "outputs": [],
   "source": [
    "a.forward(100)\n",
    "b.forward(100)\n",
    "c.forward(100)\n",
    "d.forward(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d6396e3f-be36-4c46-b65d-1c5e98614f35",
   "metadata": {},
   "outputs": [],
   "source": [
    "b.forward(10)\n",
    "c.forward(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "124fe741-6127-41c7-a506-430405cca8a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "a.left(90)\n",
    "d.right(90)\n",
    "a.forward(35)\n",
    "d.forward(35)\n",
    "a.right(90)\n",
    "d.left(90)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "94e96428-d8ba-4810-aa99-6f13137fe0d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "b.left(90)\n",
    "c.right(90)\n",
    "b.forward(17.5)\n",
    "c.forward(17.5)\n",
    "b.right(90)\n",
    "c.left(90)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f1341897-44ba-4b13-a37a-9ce1991255ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "a.forward(35)\n",
    "d.forward(35)\n",
    "b.forward(17.5)\n",
    "c.forward(17.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16c17a9c-3dd6-4d33-bb31-102595408dcb",
   "metadata": {},
   "source": [
    "# Built-in Functions\n",
    "## The `abs` Function\n",
    "The abs function returns the absolute value of a number, which is the value of a number without its sign."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c06c0e5f-9839-41e0-80e2-d06cac046628",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "69\n"
     ]
    }
   ],
   "source": [
    "print(abs(-69))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7ae4bdb1-9527-441c-824c-0ece42309435",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "69\n"
     ]
    }
   ],
   "source": [
    "print(abs(69))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e95ef30b-9b52-419e-a8fc-3886ac68c580",
   "metadata": {},
   "source": [
    "A cool way to apply this is when you want to calculate the amount of movement of a character in a game if you do not need to know the direction it is travelling. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "4cce665c-d9e7-452f-9775-72fdfd6be8c9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moving...\n"
     ]
    }
   ],
   "source": [
    "steps = -3\n",
    "if abs(steps) > 0:\n",
    "        print('Moving...')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ebf9f009-2a0a-4527-872d-941d6539ee30",
   "metadata": {},
   "source": [
    "If we were not to use the `abs` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "8df9eed9-7b43-4d43-8b72-b52c0c607bbe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Character is moving\n"
     ]
    }
   ],
   "source": [
    "steps = -3\n",
    "if steps < 0 or steps > 0:\n",
    "    print('Character is moving')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "061a3875-8c6b-48af-9e31-c1a017e4a6b4",
   "metadata": {},
   "source": [
    "## The `bool` Function\n",
    "`bool` is short for _Boolean_. When using `bool` for numbers, 0 returns a `False` while any other number returns a `True`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "4c7b2ead-0def-4e94-8e95-0dbf281ca963",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(bool(0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "3d279bc3-92fe-4853-a91e-5c64473f77c1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(bool(69))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d1d3c4b-949f-4329-81d6-6e244fac1ee6",
   "metadata": {},
   "source": [
    "When using `bool` for other values like strings, it returns `True` as long as there is a value for the string. It will only return `False` when the string is empty or has the keyword `None`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "1b07e8d0-f271-4342-906a-87ce0e99a26a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(bool(None))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "593b0f9c-58f8-487f-86f8-bf172d5e407b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(bool('a'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "12640eb8-9331-4d33-95aa-b20761f3ec05",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(bool(' '))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c9996a0-2f77-49e7-a42f-0481b30ca30b",
   "metadata": {},
   "source": [
    "It will also return `False` for lists, tuples and maps without any values. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "b0c84dcb-18ed-496d-bc19-aefc375e2edd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "my_silly_list = ['s', 'i', 'l', 'l', 'y']\n",
    "print(bool(my_silly_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "712e7142-c935-4ff8-b7c6-22a5b4d63d3f",
   "metadata": {},
   "source": [
    "### A very good use case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "8fb3dd09-51e7-48dd-ac51-5088386acfa3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Year of birth: \n"
     ]
    }
   ],
   "source": [
    "year = input('Year of birth: ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "a869c2a3-0975-4478-8790-1eeeb9d68e43",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You need to enter a value for your year of birth\n"
     ]
    }
   ],
   "source": [
    "if not bool(year.rstrip()):\n",
    "    print('You need to enter a value for your year of birth')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe3a5804-39b4-411d-8f11-bad7f1d34605",
   "metadata": {},
   "source": [
    "The `rstrip` function removes any spaces and enter characters from the end of the string."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da039d52-26b4-4ea6-bec3-ddfac6ae4bc8",
   "metadata": {},
   "source": [
    "## The `dir` Function\n",
    "can be used to show what functions you can use for a value. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b5ea424c-52fd-42c5-bcf9-9a0ad90051be",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__add__',\n",
       " '__class__',\n",
       " '__class_getitem__',\n",
       " '__contains__',\n",
       " '__delattr__',\n",
       " '__delitem__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getitem__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__iadd__',\n",
       " '__imul__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__iter__',\n",
       " '__le__',\n",
       " '__len__',\n",
       " '__lt__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__reversed__',\n",
       " '__rmul__',\n",
       " '__setattr__',\n",
       " '__setitem__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " 'append',\n",
       " 'clear',\n",
       " 'copy',\n",
       " 'count',\n",
       " 'extend',\n",
       " 'index',\n",
       " 'insert',\n",
       " 'pop',\n",
       " 'remove',\n",
       " 'reverse',\n",
       " 'sort']"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(['This', 'is', 'a', 'list'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7670326-a861-4a28-b98a-cf5cc3cdf2bf",
   "metadata": {},
   "source": [
    "Most of the functions it shows are probably useless for you as they are mainly used by Python itself. Nevertheless, the `dir` function is perfect for quickly finding out what you can do with a value. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aeda8633-9962-417d-bd31-4fc3c42d7c8b",
   "metadata": {},
   "source": [
    "### The `help` Function\n",
    "can be used to get a short summary of any function in the list. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0e9e4dba-4ccd-413b-acd9-8b1c949dcdf1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__add__',\n",
       " '__class__',\n",
       " '__contains__',\n",
       " '__delattr__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getitem__',\n",
       " '__getnewargs__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__iter__',\n",
       " '__le__',\n",
       " '__len__',\n",
       " '__lt__',\n",
       " '__mod__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__rmod__',\n",
       " '__rmul__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " 'capitalize',\n",
       " 'casefold',\n",
       " 'center',\n",
       " 'count',\n",
       " 'encode',\n",
       " 'endswith',\n",
       " 'expandtabs',\n",
       " 'find',\n",
       " 'format',\n",
       " 'format_map',\n",
       " 'index',\n",
       " 'isalnum',\n",
       " 'isalpha',\n",
       " 'isascii',\n",
       " 'isdecimal',\n",
       " 'isdigit',\n",
       " 'isidentifier',\n",
       " 'islower',\n",
       " 'isnumeric',\n",
       " 'isprintable',\n",
       " 'isspace',\n",
       " 'istitle',\n",
       " 'isupper',\n",
       " 'join',\n",
       " 'ljust',\n",
       " 'lower',\n",
       " 'lstrip',\n",
       " 'maketrans',\n",
       " 'partition',\n",
       " 'removeprefix',\n",
       " 'removesuffix',\n",
       " 'replace',\n",
       " 'rfind',\n",
       " 'rindex',\n",
       " 'rjust',\n",
       " 'rpartition',\n",
       " 'rsplit',\n",
       " 'rstrip',\n",
       " 'split',\n",
       " 'splitlines',\n",
       " 'startswith',\n",
       " 'strip',\n",
       " 'swapcase',\n",
       " 'title',\n",
       " 'translate',\n",
       " 'upper',\n",
       " 'zfill']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "music = 'I love Apple Music!'\n",
    "dir(music)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b41d3bbb-a3e4-45f7-9dbc-b623e0b358bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function upper:\n",
      "\n",
      "upper() method of builtins.str instance\n",
      "    Return a copy of the string converted to uppercase.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(music.upper)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2facb5ab-0261-4777-9407-8901f59c9ac8",
   "metadata": {},
   "source": [
    "This says that `upper` is a built-in function of the string (builtins.str)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a7836236-d890-400c-bac5-878207394300",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I LOVE APPLE MUSIC!\n"
     ]
    }
   ],
   "source": [
    "print(music.upper())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a1deaa7-0a9a-4243-93d9-6413266e392a",
   "metadata": {},
   "source": [
    "## The `eval` Function\n",
    "is not evil. It is short for _evaluate_ and uses a string as the input (parameter) and run it like a Python expression or statement. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "1daa00ff-7391-4446-9769-4760468ff619",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wow\n"
     ]
    }
   ],
   "source": [
    "eval(\"print('wow')\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9f486b9-797f-4a86-919d-5fa16789cfdd",
   "metadata": {},
   "source": [
    "_Do note that you have to use single quotation marks for the parameter and double quotation marks for `'wow'` or the other way round._\n",
    "So basically, it runs a string as Python code. This can be useful when you want the user to input a Python code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "0b96a37e-456e-48ae-9fef-23e2f67ece43",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Show one Python code you have learnt today:  print('Hello World')\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "code = input('Show one Python code you have learnt today: ')\n",
    "eval(code)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6665d0f-34af-44ab-94a4-9cadca0504a1",
   "metadata": {},
   "source": [
    "However, it only works with simple expressions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "efb741e0-5b3b-49a9-b72a-131c070b7a8b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Show one Python code you have learnt today:  import turtle\n"
     ]
    },
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<string>, line 1)",
     "output_type": "error",
     "traceback": [
      "Traceback \u001b[0;36m(most recent call last)\u001b[0m:\n",
      "  File \u001b[1;32m\"/Users/Marsh/mambaforge/lib/python3.9/site-packages/IPython/core/interactiveshell.py\"\u001b[0m, line \u001b[1;32m3444\u001b[0m, in \u001b[1;35mrun_code\u001b[0m\n    exec(code_obj, self.user_global_ns, self.user_ns)\n",
      "\u001b[0;36m  File \u001b[0;32m\"/var/folders/tf/0c8w0zdx03xg0xwmsj1rs6b00000gq/T/ipykernel_24040/572721702.py\"\u001b[0;36m, line \u001b[0;32m2\u001b[0;36m, in \u001b[0;35m<module>\u001b[0;36m\u001b[0m\n\u001b[0;31m    eval(code)\u001b[0m\n",
      "\u001b[0;36m  File \u001b[0;32m\"<string>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    import turtle\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "code = input('Show one Python code you have learnt today: ')\n",
    "eval(code)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9cdc1b7-a1d3-4ad9-b1d2-99d26932d470",
   "metadata": {},
   "source": [
    "Basically, multiple lines of code will not be evaluated. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "940b20b7-0f62-4598-9e85-b34ef9de97af",
   "metadata": {},
   "source": [
    "## The `exec` Function\n",
    "is similar to `eval`, but _can_ run complicated codes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "d4a1113d-9bd2-48a3-8623-595fc119e30b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Me gusto bread!\n"
     ]
    }
   ],
   "source": [
    "code1 = '''bread = 'staple'\n",
    "if bread == 'staple':\n",
    "    print('Me gusto bread!')'''\n",
    "exec(code1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06f718b3-4a8a-41e6-b179-61877ec68aa3",
   "metadata": {},
   "source": [
    "## The `float` Function\n",
    "converts a string or a number to a _floating-point_ number, which is a number with a decimal place. An _integer_ is a whole number, like the number 69."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "bdb2cb77-10f0-4d34-82c2-413dc0963c81",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12.69"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float('12.69')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "bd3cc079-2ce4-4fad-97da-8d0669d8844a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12.0"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float('12')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "ddc1c9ad-f0f0-44d6-8359-98e444207650",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "How old are you?  10\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You are 3 year(s) too young for this joke!\n"
     ]
    }
   ],
   "source": [
    "age = float(input('How old are you? '))\n",
    "if age < 13:\n",
    "    print('You are %s year(s) too young for this joke!' % int(13 - age))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82e7233a-c2fc-459d-a34f-81719761c02d",
   "metadata": {},
   "source": [
    "## The `int` Function\n",
    "Did you catch the `int` in the end of the code? It can be used to round down a floating-point number to its ones or convert a string to an integer. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "22e84b41-158c-42f7-8def-a24ecafb898e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "69"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(69.69)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "5d9289b8-a552-48f0-89ee-db03acd36342",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "69"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int('69')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "6d7c5677-fb79-4af4-9d2b-d55b9958ba79",
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: '69.69'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/tf/0c8w0zdx03xg0xwmsj1rs6b00000gq/T/ipykernel_24040/2033457553.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'69.69'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: '69.69'"
     ]
    }
   ],
   "source": [
    "int('69.69')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c454be3-1392-48f5-976d-9918f37c297b",
   "metadata": {},
   "source": [
    "But you cannot convert a string with a floating-point number. For that, you have to use `float` and then `int`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "57f59f74-5da3-411d-a08a-e015ab2e090a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "69"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = float('69.69')\n",
    "int(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0696376a-6008-475e-a5e3-a21bff3fd0be",
   "metadata": {},
   "source": [
    "## The `len` Function \n",
    "returns a length of an object or the number of characters in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "7fac1b21-c509-407d-945e-d10585c5d368",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len('It is what it is.')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b46535a7-67cd-477f-b1eb-9d47ce0a5acd",
   "metadata": {},
   "source": [
    "`len` returns the number of items in a list or a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "d3c1af94-4c90-40fd-902e-2b2f262ae45d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "blackbear = ['hot girl bummer', 'do re mi', 'idfc']\n",
    "print(len(blackbear))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6345dc71-737c-4f5c-ab55-424d569f478e",
   "metadata": {},
   "source": [
    "In maps, `len` returns the number of items in a map."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "f01305c2-0e06-4af3-a53f-272384c85180",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "music = {'me' : 'blackbear', 'also me' : 'Hayd'}\n",
    "print(len(music))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c64c9880-406b-464b-a3c2-2cfc13b75207",
   "metadata": {},
   "source": [
    "### A Very Good Application"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "fcf9220a-9109-442c-a54f-ae9769c85e69",
   "metadata": {},
   "outputs": [],
   "source": [
    "def chart(list):\n",
    "    length = len(list) + 1\n",
    "    for y in range(1, length):\n",
    "        print('%s. %s' % (y, list[y - 1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "91c8a807-e411-49ab-9781-61cda9b3077d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1. hot girl bummer\n",
      "2. do re mi\n",
      "3. idfc\n"
     ]
    }
   ],
   "source": [
    "chart(blackbear)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bbdf77f-a84e-4dd7-8999-940422f42a27",
   "metadata": {},
   "source": [
    "## `max` and `min`\n",
    "The `max` function returns the largest item in a list, tuple or string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "534cf655-0e28-415e-bb0b-4d6bc342f0a1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "list1 = [8, 0, 3, 5, 1, 6]\n",
    "print(max(list1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bfbf8a3b-2a1b-4b4a-a94f-1bcec0b3866e",
   "metadata": {},
   "source": [
    "In strings, this is how to get the largest item:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "acc5e1f0-9a3a-4f3d-8919-cc791cd5303b",
   "metadata": {},
   "outputs": [],
   "source": [
    "string1 = 'D,e,m,o,n,s'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d455637-9f35-4cd1-ba8d-861be8c0a5f7",
   "metadata": {
    "tags": []
   },
   "source": [
    "or"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "19a85cf7-696e-4a8e-9593-80c1a905e812",
   "metadata": {},
   "outputs": [],
   "source": [
    "string2 = 'D e m o n s'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "07a1a0d2-de54-42d3-864f-7a76034ecfc4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s\n"
     ]
    }
   ],
   "source": [
    "print(max(string1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "a63ed53d-3191-4a83-a577-0ee7d6080dcb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s\n"
     ]
    }
   ],
   "source": [
    "print(max(string2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d87cdc3-e5f7-402f-b491-d26f2c252222",
   "metadata": {},
   "source": [
    "Why 's'? Because, unlike numbers, letters are sorted alphabetically."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "e5b30137-f588-40b7-91de-2ad041543d7f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y\n"
     ]
    }
   ],
   "source": [
    "string3 = 'Y o u a r e y o u r s e l f'\n",
    "print(max(string3))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7778a6a9-85b7-4155-a36e-21e9e97015c7",
   "metadata": {},
   "source": [
    "Why 'y' and not 'Y'? Because, lowercase letters come after uppercase letters.\n",
    "Like all functions, the parameter need not be a variable that already exists. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "e4ea1242-b3fa-4854-9eba-a50132d59797",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "999\n"
     ]
    }
   ],
   "source": [
    "print(max(69, 999, 34, 35))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5cec5e4d-76b8-4170-8439-50e5f661f320",
   "metadata": {},
   "source": [
    "You can also skip the 'print' command if you want. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "aa51cb5c-681f-4a89-8ba5-dcc09c2048ad",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "169"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(69, 169)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "871b8d28-05eb-436e-ba44-029599779667",
   "metadata": {},
   "source": [
    "### A Very Good Application\n",
    "Imagine you are playing a game where there are four players who have to guess a number. If anyone guesses a number higher than the number, the game is over. If everyone's guess is lower than the number, the player who guessed the highest number wins. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "a0a4643b-e031-43da-b110-d4d6737746f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def guess():\n",
    "    print('''Welcome to the Guessing Game!\n",
    "Make sure there are four players, please.''')\n",
    "    import random\n",
    "    num = random.randint(2,99)\n",
    "    print('''Enter your guesses respectively. \n",
    "Remember, the number is below 100.''')\n",
    "    p1 = float(input('Player 1: '))\n",
    "    p2 = float(input('Player 2: '))\n",
    "    p3 = float(input('Player 3: '))\n",
    "    p4 = float(input('Player 4: '))\n",
    "    guesses = [p1, p2, p3, p4]\n",
    "    if max(guesses) > num:\n",
    "        print('You lost! The number was %s!' % num)\n",
    "    else:\n",
    "        print('Congratulations! The number was %s!' % num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "f6b5d05c-0ea4-423b-b52f-2261eb53d8ed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to the Guessing Game!\n",
      "Make sure there are four players, please.\n",
      "Enter your guesses respectively. \n",
      "Remember, the number is below 100.\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Player 1:  69\n",
      "Player 2:  34\n",
      "Player 3:  35\n",
      "Player 4:  17\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You lost! The number was 23!\n"
     ]
    }
   ],
   "source": [
    "guess()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c757ed3-798b-48ba-893d-9d96f637c207",
   "metadata": {},
   "source": [
    "We used a special module called `random` to get a completely random number!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58391b90-8adc-4dc0-b569-cb38cafff925",
   "metadata": {},
   "source": [
    "## The `range` Function\n",
    "returns a special object called an _iterator_ which repeats an action a specific number of times. It is usually used in `for` loops. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "5b1bf3b4-8e08-4770-95d0-37b373720f82",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for y in range(0, 5):\n",
    "    print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3a3d1d9-b1b9-4b73-83fa-2fc9bef7025a",
   "metadata": {},
   "source": [
    "You can also convert the `iterator` into a list with the `list` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "bc3f4c4e-62e4-482a-a3e2-c63153140405",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "list4 = list(range(0, 5))\n",
    "print(list4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e29f0d0-c038-497b-a891-422b99d2872c",
   "metadata": {},
   "source": [
    "A third parameter in `range`?! It is actually called `step`. When not given, the `step` value is 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "22937dd8-f84b-4224-95c6-0d6fcc17d8b6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "two_times = list(range(0, 12, 2))\n",
    "print(two_times)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd7f9364-e01a-4b1d-9c4b-c12da134a15d",
   "metadata": {},
   "source": [
    "You can even count down!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "939cb294-3d70-4e79-8510-0e0831824386",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]\n"
     ]
    }
   ],
   "source": [
    "countdown = list(range(60, -1, -1))\n",
    "print(countdown)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6976ae2-364d-40ca-9be3-4bfdf7d22da4",
   "metadata": {},
   "source": [
    "What if you removed the `step` value?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "f076f5c2-005c-4c50-b67b-c48aaef9d5ae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "countdown1 = list(range(60, -1))\n",
    "print(countdown)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "fafdf284-d755-447d-bb5f-3d15325937c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[12, 10, 8, 6, 4, 2]\n"
     ]
    }
   ],
   "source": [
    "countdown2 = list(range(12, 0, -2))\n",
    "print(countdown2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dadf3902-f4d2-4f7a-bc7a-213501ca9ef1",
   "metadata": {},
   "source": [
    "## The `sum` Function\n",
    "adds up all the items in a list and returns the total. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "2042a263-8d72-4f90-a581-a26c73af77ed",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1830"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(countdown)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd19ef8f-a1f0-46cf-9e72-7f3acff6244a",
   "metadata": {},
   "source": [
    "Cool, right?\n",
    "## Getting Hands-On With Files\n",
    "First, create a test text file.\n",
    "### Opening Files\n",
    "On Windows,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8d755640-72b6-4de5-a571-4dba033105af",
   "metadata": {},
   "outputs": [],
   "source": [
    "test = open('c:\\\\test.txt')\n",
    "text = test.read()\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f5df54e-b1df-4252-8cb8-3b9fa97d20d8",
   "metadata": {},
   "source": [
    "On Mac or Ubuntu,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "3d33711e-05d6-44b1-b9d4-32478752eb99",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Howdy!\n"
     ]
    }
   ],
   "source": [
    "test = open('/Users/Marsh/Desktop/test.txt')\n",
    "print(test.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "585cec5e-aad6-445e-93f9-177294f455b3",
   "metadata": {},
   "source": [
    "### Writing on Files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "ba7942fd-ac47-47d6-9684-bd66fddebf41",
   "metadata": {},
   "outputs": [],
   "source": [
    "text = open('/Users/Marsh/Desktop/test.txt', 'w')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f70a302a-122b-44da-96f5-ea61b9e10b65",
   "metadata": {},
   "source": [
    "The parameter `'w'` means that we are going to write on the file. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "9cc8c568-1a32-4a06-9b8f-56d24d896edf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text.write('This is my kingdom come')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a671b9f5-7cef-4207-9048-b4279ce75704",
   "metadata": {},
   "source": [
    "To close it, enter: (You have to close it first)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "b1b0dfb6-2d61-4237-810e-8668d30b37ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "text.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "id": "004c3561-8955-4bb5-9dd2-0f4746011998",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is my kingdom come\n"
     ]
    }
   ],
   "source": [
    "text = open('/Users/Marsh/Desktop/test.txt')\n",
    "print(text.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2e15a60-743f-495c-93f5-b8c7d1f907d0",
   "metadata": {},
   "source": [
    "## Extras\n",
    "### Mix Up Words in a String Using a Function (which has not been taught yet)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "9ecfbae1-4820-4ba2-a319-2fe16226a679",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__add__',\n",
       " '__class__',\n",
       " '__contains__',\n",
       " '__delattr__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getitem__',\n",
       " '__getnewargs__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__iter__',\n",
       " '__le__',\n",
       " '__len__',\n",
       " '__lt__',\n",
       " '__mod__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__rmod__',\n",
       " '__rmul__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " 'capitalize',\n",
       " 'casefold',\n",
       " 'center',\n",
       " 'count',\n",
       " 'encode',\n",
       " 'endswith',\n",
       " 'expandtabs',\n",
       " 'find',\n",
       " 'format',\n",
       " 'format_map',\n",
       " 'index',\n",
       " 'isalnum',\n",
       " 'isalpha',\n",
       " 'isascii',\n",
       " 'isdecimal',\n",
       " 'isdigit',\n",
       " 'isidentifier',\n",
       " 'islower',\n",
       " 'isnumeric',\n",
       " 'isprintable',\n",
       " 'isspace',\n",
       " 'istitle',\n",
       " 'isupper',\n",
       " 'join',\n",
       " 'ljust',\n",
       " 'lower',\n",
       " 'lstrip',\n",
       " 'maketrans',\n",
       " 'partition',\n",
       " 'removeprefix',\n",
       " 'removesuffix',\n",
       " 'replace',\n",
       " 'rfind',\n",
       " 'rindex',\n",
       " 'rjust',\n",
       " 'rpartition',\n",
       " 'rsplit',\n",
       " 'rstrip',\n",
       " 'split',\n",
       " 'splitlines',\n",
       " 'startswith',\n",
       " 'strip',\n",
       " 'swapcase',\n",
       " 'title',\n",
       " 'translate',\n",
       " 'upper',\n",
       " 'zfill']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "blackbear = 'Queen of Broken Hearts'\n",
    "dir(blackbear)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "71841d04-a932-4a4a-8d79-79fdbb4f7387",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function split:\n",
      "\n",
      "split(sep=None, maxsplit=-1) method of builtins.str instance\n",
      "    Return a list of the words in the string, using sep as the delimiter string.\n",
      "    \n",
      "    sep\n",
      "      The delimiter according which to split the string.\n",
      "      None (the default value) means split according to any whitespace,\n",
      "      and discard empty strings from the result.\n",
      "    maxsplit\n",
      "      Maximum number of splits to do.\n",
      "      -1 (the default value) means no limit.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(blackbear.split)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "736a0341-840e-483c-bf6f-0d93c3543b92",
   "metadata": {},
   "source": [
    "Cool! So the`split` function can break a string into words! Let's try it out in a functon!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "fdc1875c-e855-4d0f-bb4b-4eb2ff7b973e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def randomise(strX):\n",
    "    listX = strX.split()\n",
    "    import random\n",
    "    random.shuffle(listX)\n",
    "    print(listX)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "e7dad235-ac3b-484e-bb1d-b16f5fc2a029",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Queen', 'Hearts', 'of', 'Broken']\n"
     ]
    }
   ],
   "source": [
    "randomise(blackbear)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4addecd-f678-4959-ad4c-e8d81788df92",
   "metadata": {},
   "source": [
    "Next, we have to convert the list to a string..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "d2b0836f-01b9-4458-b09e-e9f1e8fad41e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function join:\n",
      "\n",
      "join(iterable, /) method of builtins.str instance\n",
      "    Concatenate any number of strings.\n",
      "    \n",
      "    The string whose method is called is inserted in between each given string.\n",
      "    The result is returned as a new string.\n",
      "    \n",
      "    Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(' '.join)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "298337c6-32c9-4900-ad6e-d18cdd04bb33",
   "metadata": {},
   "source": [
    "So the `join` function can do that! Let's add that to our code!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "d3bf33ca-db49-4ef1-9c68-8ec645a75a9b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def randomise(strX):\n",
    "    import random\n",
    "    listX = strX.split()\n",
    "    random.shuffle(listX)\n",
    "    listX = ' '.join(listX)\n",
    "    print(listX)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c31a2de9-5e9e-4e31-baf2-39055f5174e1",
   "metadata": {},
   "source": [
    "# Useful Python Modules\n",
    "The `copy` module basically keeps a backup of variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "8707a02a-2de6-4422-8b1a-5632ba08159e",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Human:\n",
    "    def __init__(self, iq):\n",
    "        self.iq = iq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "97d8ed0c-c227-4d42-b1c6-c5b05ade6245",
   "metadata": {},
   "outputs": [],
   "source": [
    "mars = Human(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c0dd6fd-902f-41fe-a36c-adc1cf0f8e9d",
   "metadata": {},
   "source": [
    "Say, we want to keep Mars' identity safe and backed up."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "81690622-4de4-4c08-b2d4-7591548f51d5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "269\n",
      "269\n"
     ]
    }
   ],
   "source": [
    "import copy\n",
    "mars_backup = copy.copy(mars)\n",
    "print(mars.iq)\n",
    "print(mars_backup.iq)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29a1b725-708e-48a3-bacc-7a5a9e903d7c",
   "metadata": {},
   "source": [
    "Cool! Let's change Mars' IQ!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "e17ba338-ff2b-47f8-a0f4-8862062270c4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "269\n",
      "269\n"
     ]
    }
   ],
   "source": [
    "mars.iq = 269\n",
    "print(mars.iq)\n",
    "print(mars_backup.iq)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be90b16a-df58-402a-ae35-7678e863a243",
   "metadata": {},
   "source": [
    "Yes, the IQ of Mars increases, and so does his clone! This is called using a _shallow copy_. Okay, but why use _shallow copy_ when you can just use _Multiple-Target Assignment_ (https://www.geeksforgeeks.org/different-forms-of-assignment-statements-in-python/#:~:text=Multiple%2D%20target%20assignment)?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "535153db-9895-48f5-beca-592bb60b98d2",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Cow:\n",
    "    def __init__(self, spots):\n",
    "        self.spots = spots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "6a6b0d6c-e5e5-46d3-9e70-4afd76af83c7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "69\n",
      "69\n"
     ]
    }
   ],
   "source": [
    "moo1 = moo2 = Cow(69)\n",
    "print(moo1.spots)\n",
    "print(moo2.spots)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "b6ec7672-5ba2-4b75-bdd0-2818c3ef96ab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "90\n",
      "90\n"
     ]
    }
   ],
   "source": [
    "moo1.spots += 21\n",
    "print(moo1.spots)\n",
    "print(moo2.spots)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "157bdb91-c566-4b45-a498-8ddca08edcbb",
   "metadata": {},
   "source": [
    "They seem to be the same...\n",
    "However, when using multiple-target assignments, there is only one instance of that list in the memory. But in shallow copy, each list’s object has its own, independent memory address."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "5380d027-bb6e-4729-b632-72aa2a801c19",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "id of a - 2363634226816, id of b - 2363634226816\n"
     ]
    }
   ],
   "source": [
    ">>> a = [1, 2, 3, 4, 5]\n",
    ">>> b = a\n",
    ">>> id(a) == id(b)\n",
    ">>> print('id of a - {}, id of b - {}'.format(id(a), id(b)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc58f6f8-5b0c-430d-b22e-252a37d93aa2",
   "metadata": {},
   "source": [
    "Whereas in shallow copy, you'd get different IDs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "0bfde9bd-e4cc-4ea8-b9cd-f996ca658c9c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "id of a1 - 2363628591296, id of b2 - 2363604127680\n"
     ]
    }
   ],
   "source": [
    ">>> a1 = [1, 2, 3, 4, 5]\n",
    ">>> b2 = copy.copy(a)\n",
    ">>> print('id of a1 - {}, id of b2 - {}'.format(id(a), id(b)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "aa47ed46-36a7-4749-b67a-ddd52c591fa0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a1[0] - 2363539521776 , b2[0] - 2363539521776\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> print('a1[0] - {} , b2[0] - {}'.format(id(a1[0]), id(b2[0])))       \n",
    ">>> id(a1[0]) == id(b2[0])\n",
    ">>> id(a1[1]) == id(b2[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a4f193d-5623-41cd-819f-4f0e5b9460b8",
   "metadata": {},
   "source": [
    "As shown above, each item in the list share the same IDs when shallow copied. Thus, the contents are synced. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "e2cf0494-5613-41f4-a02f-17d292ac417b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "a1.append(6)\n",
    "print(len(a1))\n",
    "print(len(b2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78922e71-9fda-4259-b876-1378ef269046",
   "metadata": {},
   "source": [
    "While each item in the lists are synced, any item added in `a1` will not be added to its duplicate.\n",
    "\n",
    "The `copy` module also has a function for _deep copying_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "a3617ec8-2961-4d58-96c7-825e881612a3",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Goat:\n",
    "    def __init__(self, age):\n",
    "        self.age = age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "9c9f8b36-f26a-48c5-87b6-1389571d6a38",
   "metadata": {},
   "outputs": [],
   "source": [
    "goatzee = Goat(17)\n",
    "goatzee_2 = copy.deepcopy(goatzee)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "330bc0be-0b7f-4669-9215-e1781de3eaeb",
   "metadata": {},
   "outputs": [],
   "source": [
    "goatzee.age += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9aed5c8-858c-4eeb-a794-e53e8659ea42",
   "metadata": {},
   "source": [
    "_sidenote: `+=` is the same as `goatzee.age = goatzee.age + 1`_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "51f62f97-f9eb-433e-8f4b-bd42afa29f49",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18\n",
      "17\n"
     ]
    }
   ],
   "source": [
    "print(goatzee.age)\n",
    "print(goatzee_2.age)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05699f6b-74ea-451f-ad94-637fbcf3cc95",
   "metadata": {},
   "source": [
    "So _deep copying_ duplicates `goatzee` first, but fails to keep up with it.\n",
    "\n",
    "The `copy` module can be really relevant only for variables which contain other variables.\n",
    "## The `keyword` Module\n",
    "can help keep track of keywords."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "ba4de2ff-f534-4a95-9e70-c8d27b96d95a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']\n"
     ]
    }
   ],
   "source": [
    "import keyword\n",
    "print(keyword.kwlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "199bfe4b-951c-4fdb-bdf7-0ec2a1f73cf8",
   "metadata": {},
   "source": [
    "A Python `keyword` is any word in Python that is part of the language itself. The variable `kwlist` contains all the Python keywords. The function `iskeyword` returns `True` if any string is a keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "dea01824-36a7-4f4c-83d4-302c1d0fc3ab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "keyword.iskeyword('def')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "672d64c9-857f-45c6-88d2-a431f3bcdfcb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "keyword.iskeyword('marsh')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "094f841d-229b-4f15-bc76-d21851b7d22f",
   "metadata": {},
   "source": [
    "## The `random` Module\n",
    "is very uselful for randomising things. Some useful funtions are `randint`, `choice` and `shuffle`. \n",
    "### The `randint` Funtion \n",
    "can pick a 'random' number between two numbers, say, 1 and 69. The number picked can also be 1 and 69 themselves."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "128604c1-fc8b-47e4-b744-fe5603ffaa7d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "47\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "print(random.randint(1, 69))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9915f35a-550c-4ba3-b03c-1da5e972611b",
   "metadata": {},
   "source": [
    "### The `choice` Function\n",
    "can be used to pick a 'random' item from a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "9477df41-f4bf-4107-a066-b9b5e6e9e713",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Juice WRLD\n"
     ]
    }
   ],
   "source": [
    "sampleList = ['blackbear', 'The Kid LAROI', 'Juice WRLD']\n",
    "print(random.choice(sampleList))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac9f4807-69e4-4dec-abd8-35c3aa35eddf",
   "metadata": {},
   "source": [
    "### The `shuffle` Function\n",
    "mixes up the items in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "98175ba0-6d7c-41fa-bc61-e61f1859b130",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['blackbear', 'Juice WRLD', 'The Kid LAROI']\n"
     ]
    }
   ],
   "source": [
    "list2 = copy.deepcopy(sampleList)\n",
    "random.shuffle(list2)\n",
    "print(list2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24814eb3-4c68-45f0-92f5-87054ace76b7",
   "metadata": {},
   "source": [
    "## The `sys` Module\n",
    "contains system functions to control the Python shell.\n",
    "### The `stdin` Object\n",
    "allows for user input. The `input` function does something similar, but using the `stdin` object lets you choose the character limit when it is reading what the user has entered. (As of Dec 2021, this does not work on JupyterLab.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "7c5f7612-6cf2-409f-8025-2427bf156713",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "x = sys.stdin.readline(4)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8bb8d73-6613-4713-ae34-6968804c2df3",
   "metadata": {},
   "source": [
    "### The `stdout` Object\n",
    "is the opposite of `stdin`, which stands for _standard input_. `stdout` is _standard output_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "d594b7cc-dbef-4fd5-a092-9871edc4a6c4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Howdy!"
     ]
    },
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sys.stdout.write('Howdy!')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd1bba5c-e984-46cf-8108-e445d008c1b5",
   "metadata": {},
   "source": [
    "The number in the end represents the characters it has written.\n",
    "### Seeing the version of your Python shell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b40d6c24-6ab3-4632-a942-d8305d8fc2a0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3.10.0 (tags/v3.10.0:b494f59, Oct  4 2021, 19:00:18) [MSC v.1929 64 bit (AMD64)]'"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sys.version"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72e669ed-61b2-43a2-a78e-15300b41b1b4",
   "metadata": {},
   "source": [
    "## The `time` Module\n",
    "can display the time,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "80e55bda-bfef-46de-a5b4-691bb0ec5b66",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1638440671.67505\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "print(time.time())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53fdd618-0ef5-4f4f-9694-c85e1ab8e5f5",
   "metadata": {},
   "source": [
    "in an unconventional way. This is actually the number of seconds since 1 January 1970 at 00:00:00 AM. However, this can be useful, say, when you want to measure how long it takes your code to run."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e1852dd0-9149-4510-b9f0-6f2af129b0eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "def numY(num):\n",
    "    start = time.time()\n",
    "    for x in range(0, num):\n",
    "        print(x)\n",
    "    end = time.time()\n",
    "    print('This code took %s to be executed.' % (end - start))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "94ae331b-308f-49ed-bbaf-5ce9db0ae87e",
   "metadata": {},
   "outputs": [],
   "source": [
    "numY(69)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f05fa5fb-20f4-4dce-95fd-2066d81f6328",
   "metadata": {},
   "source": [
    "### A more conventional way of telling the time\n",
    "using the `asctime` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9b646873-e6e7-4855-b8a4-58a70b9ae4ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(time.asctime())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25189a30-7006-4927-91bc-98be7b116c09",
   "metadata": {},
   "source": [
    "### Converting a Date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "1ad09f2f-d4c7-4252-ba83-849b72c54ccc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fri Mar 12 10:10:10 2021\n"
     ]
    }
   ],
   "source": [
    "date = (2021, 3, 12, 10, 10, 10, 4, 0, 0)\n",
    "print(time.asctime(date))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e56a26a2-9f06-49d2-bd93-6694a3d60804",
   "metadata": {},
   "source": [
    "The values in the sequence are year, month, day, hours, minutes, seconds, day of the week (0 is Monday, 1 is Tuesday, and so \n",
    "on), day of the year (we put 0 as a placeholder), and whether or not \n",
    "it is daylight saving time (0 if it isn’t; 1 if it is). And remember, the parameter __MUST__ be a tuple.\n",
    "### The `localtime` Function\n",
    "returns the date and time and stuff in the same order as an `asctime` input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "id": "964a8d20-fef2-4bff-9089-44958f2454ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time.struct_time(tm_year=2021, tm_mon=12, tm_mday=2, tm_hour=18, tm_min=8, tm_sec=46, tm_wday=3, tm_yday=336, tm_isdst=0)\n"
     ]
    }
   ],
   "source": [
    "print(time.localtime())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "ae5bfb16-5391-4e65-a549-577d708073ec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "336\n"
     ]
    }
   ],
   "source": [
    "print(time.localtime()[7])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99c8976d-b170-4be3-ab15-022a7583d48e",
   "metadata": {},
   "source": [
    "Using this piece of code above, we can find out the day of the year.\n",
    "### The `sleep` Function\n",
    "can be used to delay your programme."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "fd14b012-66b6-4652-b994-59667751b542",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "60\n",
      "59\n",
      "58\n",
      "57\n",
      "56\n",
      "55\n",
      "54\n",
      "53\n",
      "52\n",
      "51\n",
      "50\n",
      "49\n",
      "48\n",
      "47\n",
      "46\n",
      "45\n",
      "44\n",
      "43\n",
      "42\n",
      "41\n",
      "40\n",
      "39\n",
      "38\n",
      "37\n",
      "36\n",
      "35\n",
      "34\n",
      "33\n",
      "32\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_8048/1738028529.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m60\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m-\u001b[0m\u001b[1;36m1\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[0;32m      2\u001b[0m     \u001b[0mprint\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[0m\n\u001b[1;32m----> 3\u001b[1;33m     \u001b[0mtime\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msleep\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      4\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Happy New Year!'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "for x in range(60, -1, -1):\n",
    "    print(x)\n",
    "    time.sleep(1)\n",
    "print('Happy New Year!')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "946c647f-6603-4c8c-998a-f96699177406",
   "metadata": {},
   "source": [
    "Cool, we just made a countdown! I'm using this for New Year's Eve!\n",
    "## The `pickle` Module\n",
    "can be used to store information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "be1dbd8f-6eaf-4ace-ab48-b4c4b23d415d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "fightData = {\n",
    "    'Health' : 100,\n",
    "    'Weapons' : ['Pistol', 'Katana'],\n",
    "    'Moves' : ['The idk Move', 'The Cool One', 'Play Dead']\n",
    "}\n",
    "save = open('save.dat', 'wb')\n",
    "pickle.dump(fightData, save)\n",
    "save.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b69e125f-ce85-4cd2-8376-6a058c7bfb21",
   "metadata": {},
   "source": [
    "Python would download a file called save.dat. If you were to open the file on a text editor like Notepad++, you'd see that everything is scrambled and encrypted. However, you can easily decrypt the file using Python!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "7b4cf4d2-44b6-49aa-82a1-ff3f49548bd4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Health': 100, 'Weapons': ['Pistol', 'Katana'], 'Moves': ['The idk Move', 'The Cool One', 'Play Dead']}\n"
     ]
    }
   ],
   "source": [
    "load = open('C:/Users/icoes/Desktop/save.dat', 'rb')\n",
    "loaded = pickle.load(load)\n",
    "load.close()\n",
    "print(loaded)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "128c9562-72fe-4a33-95ca-086cee07fabe",
   "metadata": {},
   "source": [
    "That's it! We're done with this chapter!!! Except for the challenges!\n",
    "## Challenge 1: Copied Cars\n",
    "Guess what the following code will print:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "728a8eb4-0bc1-40e8-b7e6-7be8916296c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "import copy\n",
    "class Car:\n",
    "    pass\n",
    "car1 = Car()\n",
    "car1.wheels = 4\n",
    "car2 = car1\n",
    "car2.wheels = 3\n",
    "print(car1.wheels)\n",
    "car3 = copy.copy(car1)\n",
    "car3.wheels = 6\n",
    "print(car1.wheels)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8cc544ae-b0e4-4298-afac-8a20413252c7",
   "metadata": {},
   "source": [
    "## Challenge 2: Pickled Favourites"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "9bd65516-ec0b-40f8-9388-41f41b8034f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "fave = ['Coding', 'Music', 'Eating']\n",
    "save = open('fave.dat', 'wb')\n",
    "pickle.dump(fave, save)\n",
    "save.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "5a125ac9-71a3-470e-b6ef-aae584dde8ba",
   "metadata": {},
   "outputs": [
    {
     "ename": "FileNotFoundError",
     "evalue": "[Errno 2] No such file or directory: 'C:/Users/icoes/Desktop/fave.dat'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_7388/2186684613.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mload\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mopen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'C:/Users/icoes/Desktop/fave.dat'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'rb'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[0mfaveloaded\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mpickle\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mload\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mload\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mload\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mclose\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[0;32m      4\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfaveloaded\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'C:/Users/icoes/Desktop/fave.dat'"
     ]
    }
   ],
   "source": [
    "load = open('C:/Users/icoes/Desktop/fave.dat', 'rb')\n",
    "faveloaded = pickle.load(load)\n",
    "load.close()\n",
    "print(faveloaded)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "221d1951-597b-43f4-9eae-9876dd62fc75",
   "metadata": {},
   "source": [
    "# Turtle Graphics\n",
    "can let you draw more advanced geometric shapes, create different \n",
    "colors, and even fill your shapes with color!\n",
    "## Using `for` loops\n",
    "##### to create a basic square:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "1f60e61e-e1fa-47f2-a13d-8a787f70e233",
   "metadata": {},
   "outputs": [],
   "source": [
    "import turtle\n",
    "t = turtle.Pen()\n",
    "for x in range(1, 5):\n",
    "    t.forward(50)\n",
    "    t.left(90)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a5e5b80-98a4-4292-bde4-9046d99a760e",
   "metadata": {},
   "source": [
    "##### to draw a star:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a81ce4e5-2d65-43a2-b380-09220e6a803d",
   "metadata": {},
   "outputs": [],
   "source": [
    "t.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "feec4e9b-cb4f-42d0-a8fb-e708a3598541",
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in range (1, 6):\n",
    "    t.forward(100)\n",
    "    t.left(144)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "064dad2d-335e-47a8-87f3-4cead130b64e",
   "metadata": {},
   "source": [
    "##### to draw superstars."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "f8d862ff-7874-4e0c-894c-e2068c778e23",
   "metadata": {},
   "outputs": [],
   "source": [
    "t.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "3d28592a-ec36-4051-a769-da9d5dc544d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in range(1, 38):\n",
    "    t.forward(100)\n",
    "    t.left(175)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "585b9c0f-0e89-4495-a9fa-4575d51146c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "t.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "546228a5-96d8-443f-b660-a5ebe1412dd9",
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in range(1, 20):\n",
    "    t.forward(100)\n",
    "    t.left(95)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "f13f8250-56c9-436d-a798-af98661fb644",
   "metadata": {},
   "outputs": [],
   "source": [
    "t.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "cce053e3-9463-4b1e-8a18-a72ad556be79",
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in range(1, 19):\n",
    "    t.forward(100)\n",
    "    if x % 2 == 0:\n",
    "        t.left(175)\n",
    "    else:\n",
    "        t.left(225)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3528daf9-7a8e-4c2b-be53-a6d57b8bc3ef",
   "metadata": {},
   "source": [
    "## Drawing a Car\n",
    "### The Frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "4f0b5c75-84fc-41ed-91ab-e42511966966",
   "metadata": {},
   "outputs": [],
   "source": [
    "t.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "36b9c9b3-5b1b-4281-a51a-1e44a92761c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "t.color(1,0,0)\n",
    "t.begin_fill()\n",
    "t.forward(100)\n",
    "t.left(90)\n",
    "t.forward(20)\n",
    "t.left(90)\n",
    "t.forward(20)\n",
    "t.right(90)\n",
    "t.forward(20)\n",
    "t.left(90)\n",
    "t.forward(60)\n",
    "t.left(90)\n",
    "t.forward(20)\n",
    "t.right(90)\n",
    "t.forward(20)\n",
    "t.left(90)\n",
    "t.forward(20)\n",
    "t.end_fill()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7cfc3ef8-db1b-4738-a8e0-bb9731c164f0",
   "metadata": {},
   "source": [
    "### The Wheels:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "dc3a0277-6581-4a59-a94e-8f1c58aca39a",
   "metadata": {},
   "outputs": [],
   "source": [
    "t.color(1,0,0)\n",
    "t.up()\n",
    "t.forward(10)\n",
    "t.down()\n",
    "t.begin_fill()\n",
    "t.circle(10)\n",
    "t.end_fill()\n",
    "\n",
    "t.setheading(0)\n",
    "t.up()\n",
    "t.forward(90)\n",
    "t.right(90)\n",
    "t.forward(10)\n",
    "t.setheading(0)\n",
    "t.begin_fill()\n",
    "t.down()\n",
    "t.circle(10)\n",
    "t.end_fill()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eba8144e-0735-463d-8e9f-c710ce52e329",
   "metadata": {},
   "source": [
    "And you'll see a rather vague drawing of a car. We have used some new turtle functions such as `color`, which is used to change the pen colour, `begin_fill` and `end_fill` which fills in an area of the canvas with the pen color, `circle` draws a circle using the parameter (of the function) (it is not actually the parameter, but the radius) and `setheading`, which is used to turn the turtle to face a certain direction.\n",
    "\n",
    "The color function taked three parameters, which are RGB. But instead of having the base of 100, each parameter has the base of 1. For example, `color(1, 0, 0)` will give you 1, or 100% red."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "d26b4f96-9ba2-4136-ae5d-db444f59a417",
   "metadata": {},
   "outputs": [],
   "source": [
    "t.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "9dbce7f2-ef14-4f12-88ad-d30111a5ee7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "t.color(0, 0, 0)\n",
    "t.begin_fill()\n",
    "t.circle(300)\n",
    "t.end_fill()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b16b8fb6-a748-4b5b-8b01-8ebef0288d9b",
   "metadata": {},
   "source": [
    "# Using `tkinter` for Better Graphics\n",
    "Using `turtle` _works_. But they are slowww. So they are **not** ideal for more intense graphics.\n",
    "## A Clickable Button"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "630daff9-57b1-4b22-a4b4-cc57972da89d",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eab11edb-4c16-4760-a6cc-6572e0af9313",
   "metadata": {},
   "source": [
    "_sidenote:_ `from <module-name> import *` _allows you to access contents of a module without using its name. For example, we could use_\n",
    "\n",
    "`from turtle import *`\n",
    "\n",
    "`t = Pen()`\n",
    "\n",
    "_instead of_\n",
    "\n",
    "`import turtle`\n",
    "\n",
    "`t = turtle.Pen()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f3861a38-d51f-4c82-96ed-bc525a96ee76",
   "metadata": {},
   "outputs": [],
   "source": [
    "tk = Tk()\n",
    "def lunch():\n",
    "    print('LUNCH!!!')\n",
    "button = Button(tk, text = 'Tap me to have...', command = lunch)\n",
    "button.pack()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2686510-4a2b-460f-8425-7fda0ea80998",
   "metadata": {},
   "source": [
    "Had fun?! We used named parameters here. What are they?\n",
    "\n",
    "Named parameters are basically parameters with values with different orders since we name them explicitly. This can be useful if we do not need to provide a value for every parameter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "16f38f7f-d1e4-4606-9659-ebfd4ae2a871",
   "metadata": {},
   "outputs": [],
   "source": [
    "def person(CS, IQ):\n",
    "    CS = CS.casefold()\n",
    "    CS = CS.strip()\n",
    "    print('I am strong in %s and have an IQ of %s.' % (CS, IQ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "d4ee2d7a-bcb4-4562-82a5-0b09c3334ce8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am strong in humilty and have an IQ of 269.\n"
     ]
    }
   ],
   "source": [
    "person('Humilty', 269)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e509f9fc-e9f9-4888-b30e-365f7ac718c5",
   "metadata": {},
   "source": [
    "Or:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "b6749552-fd1b-4714-9fdf-11e886e463f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am strong in humility and have an IQ of 266.\n"
     ]
    }
   ],
   "source": [
    "person(IQ = 266, CS = 'humility')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e5e70c7-0b6b-4bd8-93cc-cd5bde5f6cee",
   "metadata": {},
   "source": [
    "Those were named parameters.\n",
    "## Creating a Canvas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "1a7b2028-b4f8-4302-bf30-d3ee15fcb1fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "tk = Tk()\n",
    "canvas = Canvas(tk, width=500, height=500)\n",
    "canvas.pack()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4298989c-f77b-4f4a-bf43-027269de8554",
   "metadata": {},
   "source": [
    "This basically creates a canvas which is 500 by 500 pixels large.\n",
    "## Drawing Lines\n",
    "using pixel coordinates, which determine the position of pixels on the screen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "cd8933e7-2a87-46a3-b9c8-476d50309533",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "canvas.create_line(0, 0, 500, 500)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a09c77e-f59e-435b-8111-e9fd768f2bb0",
   "metadata": {},
   "source": [
    "The 1 returned is an identifier, which we'll learn more about later! Now, if we were to use the `turtle` module to do this, it would take more lines of code.\n",
    "## Drawing Boxes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "8ed88fb1-b527-4e25-8825-d906d312e574",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "canvas.create_rectangle(10, 10, 50, 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f961ebf-32d7-4862-b0c8-ce500efcc2eb",
   "metadata": {},
   "source": [
    "We basically drew a square on the top-left corner of the window. The two parameters are actually the distance from the left side of the window and top of the window in the start and in the end respectively. We can use the code names `x1`, `y1`, `x2`, `y2`.\n",
    "## Spamming Rectangles With Random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "2507be25-9803-4824-a2cb-a7b3887326f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "import random\n",
    "tk = Tk()\n",
    "canvas = Canvas(tk, width=400, height=400)\n",
    "canvas.pack()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "2b06a558-4a15-42a3-bf2a-306a8fbba116",
   "metadata": {},
   "outputs": [],
   "source": [
    "def recto(width, height):\n",
    "    x1 = random.randrange(2, width)\n",
    "    y1 = random.randrange(2, height)\n",
    "    x2 = random.randrange(x1)\n",
    "    y2 = random.randrange(y1)\n",
    "    canvas.create_rectangle(x1, y1, x2, y2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bedb8a1b-59d6-49e5-a7a3-83958ac98958",
   "metadata": {},
   "source": [
    "Hooray!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "45eed958-db68-4030-877c-90ac9e4d0556",
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in range(0, 999):\n",
    "    recto(500, 500)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c095391a-3995-41d0-8655-d3e682f2b62d",
   "metadata": {},
   "source": [
    "And we just created a black canvas with white spaces.\n",
    "Or... nvm.\n",
    "## Making it Colourful"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "596288d3-6f4a-418f-875c-292d8f1dfddb",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "import random\n",
    "tk = Tk()\n",
    "canvas = Canvas(tk, width=400, height=400)\n",
    "canvas.pack()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "70436e9f-ddec-411f-bdff-f9640a183b8f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def modern(width, height, fill_color):\n",
    "    x1 = random.randrange(width)\n",
    "    y1 = random.randrange(height)\n",
    "    x2 = random.randrange(x1 + random.randrange(width))\n",
    "    y2 = random.randrange(y1 + random.randrange(height))\n",
    "    canvas.create_rectangle(x1, y1, x2, y2, fill=fill_color)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a44cc25-283e-4398-b824-a7fa5220ad0d",
   "metadata": {},
   "source": [
    "There is a new parameter called `fill_colour` which can be 'green', 'red' and so on. It can even be a hex code!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "6848b6d6-b8b9-43f4-b48a-58baa352f197",
   "metadata": {},
   "outputs": [],
   "source": [
    "modern(500, 500, '#098f5e')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a99e855a-7b6f-412d-b895-5bb55c2a5778",
   "metadata": {},
   "source": [
    "And a coloured box appears.\n",
    "\n",
    "## Colour Chooser"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "67662bba-333a-438e-af53-a1a09a964e87",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((128, 128, 192), '#8080c0')"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from tkinter import colorchooser\n",
    "tk = Tk()\n",
    "tk.update()\n",
    "colorchooser.askcolor()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ecad599-fab7-4572-bd7c-46171fdde3a7",
   "metadata": {},
   "source": [
    "Due to some compatibility issues, we have to update some junk. The output is a tuple containing the RGB and Hex Code respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "5738497d-4ac6-4eda-8131-2b90a9cb44ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import colorchooser\n",
    "import random\n",
    "tk = Tk()\n",
    "tk.update()\n",
    "canvas = Canvas(tk, width=400, height=400)\n",
    "canvas.pack()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "35dcb0ee-11cd-41eb-9d1e-72957e6da9da",
   "metadata": {},
   "outputs": [],
   "source": [
    "def modern(width, height, fill_color):\n",
    "    x1 = random.randrange(width)\n",
    "    y1 = random.randrange(height)\n",
    "    x2 = random.randrange(x1 + random.randrange(width))\n",
    "    y2 = random.randrange(y1 + random.randrange(height))\n",
    "    canvas.create_rectangle(x1, y1, x2, y2, fill=fill_color)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f85beaf2-6ca9-49ad-b961-1e783380a096",
   "metadata": {},
   "outputs": [],
   "source": [
    "c = colorchooser.askcolor()\n",
    "for x in range(0, 69):\n",
    "    modern(400, 400, c[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e1eb680-7035-4fed-9ef3-3768322a8df5",
   "metadata": {},
   "source": [
    "Ugh! `tkinter` is so unuasable! But nevermind!\n",
    "## Drawing Arcs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ac791ccd-ea34-49f0-b253-5523e57ec56c",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "tk = Tk()\n",
    "canvas = Canvas(tk, width=400, height=400)\n",
    "canvas.pack()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "479f2e9c-7826-4070-bb5f-3a4b29b9c4e4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "canvas.create_arc(10, 10, 200, 100, extent=180, style=ARC)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "512ed2d6-fb27-442d-961a-fe26efa9487d",
   "metadata": {},
   "source": [
    "The first 2 numbers are the coordinates for the arc. So 10 pixels across and 10 pixels down. The 200 and 100 refers to the size of the arc. This image will help you understand it more: https://photos.app.goo.gl/iEXdScWUV6WPwPXU7\n",
    "Also, the `extent` refers to the degrees of the angle of the arc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a6ea602a-b2cc-4193-9cfd-920ed79d3263",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from tkinter import *\n",
    "tk = Tk()\n",
    "canvas = Canvas(tk, width=400, height=400)\n",
    "canvas.pack()\n",
    "canvas.create_arc(10, 10, 200, 80, extent=45, style=ARC)\n",
    "canvas.create_arc(10, 80, 200, 160, extent=90, style=ARC)\n",
    "canvas.create_arc(10, 160, 200, 240, extent=135, style=ARC)\n",
    "canvas.create_arc(10, 240, 200, 320, extent=180, style=ARC)\n",
    "canvas.create_arc(10, 320, 200, 400, extent=359, style=ARC)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3bdcb35c-6fec-4bab-8471-4014596ac0a9",
   "metadata": {
    "tags": []
   },
   "source": [
    "https://photos.app.goo.gl/Sn9Z1WebkVs1dX5W8\n",
    "That is what you'll get. In the final circle, we used 359 degrees instead of 360 or else tkinter would see it as 0 degrees and draw nothing.\n",
    "## Drawing Polygons\n",
    "A polygon is any shape with three or more sides. There are regularly shaped polygons like triangles, squares, rectangles, pentagons, \n",
    "hexagons, and so on, as well as irregular ones with uneven edges, \n",
    "many more sides, and odd shapes. Using `tkinter`, we must provide the coordinates for each point of the figure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "26a4e774-a7f2-41f1-936a-0bff2b5c7a12",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "tk = Tk()\n",
    "canvas = Canvas(tk, width=400, height=400)\n",
    "canvas.pack()\n",
    "canvas.create_polygon(10, 10, 100, 10, 100, 110, fill=\"\", \n",
    "outline=\"black\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3661afc-1f6b-45ec-abb2-5619fc10d3be",
   "metadata": {},
   "source": [
    "You'd see this: https://photos.app.goo.gl/pex9ZvVsfRLnBt1v7\n",
    "\n",
    "The numbers ①, ② and ③ refer to the pairs of coordinates in the code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "aecb00ef-3253-492f-b454-dcbb0c8e81a3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "canvas.create_polygon(200, 10, 240, 30, 120, 100, 140, 120, fill=\"\", \n",
    "outline=\"black\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00978093-5260-4848-bbbe-4ef9f50006f3",
   "metadata": {},
   "source": [
    "And you'd see this weird 4-pointed figure: https://photos.app.goo.gl/Ven3gtvigYyHW2hT7\n",
    "\n",
    "Again, the numbers in circles refer to the pairs of coordinates.\n",
    "## Displaying Text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "ffd6ff30-5700-4068-9ae6-d30bd98e971b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from tkinter import *\n",
    "tk = Tk()\n",
    "canvas = Canvas(tk, width=400, height=400)\n",
    "canvas.pack()\n",
    "canvas.create_text(150, 100, text='I\\'m so productive')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "632a9699-a2f8-42ad-bb21-2a58084426d3",
   "metadata": {},
   "source": [
    "And a rather blurry text comes on. You can also change the colour and position of the text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "4797d171-61ea-4336-9ba8-261f1ee7b676",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "canvas.create_text(50, 10, text='I\\'m so productive!', fill = 'cyan')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4be9264-d69b-4b14-8287-eea30c3a04a1",
   "metadata": {},
   "source": [
    "But do note that the horizontal coordinate refers the the complete right side of the text, so you do want to leave some space for the text itself. But at least you can change the font!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "6833f245-903b-4410-b43c-1eee4257b693",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "canvas.create_text(80, 10, text='I\\'m so productive!', font=('Helvetica', 14))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd514535-adba-4288-a363-2541dff173b5",
   "metadata": {},
   "source": [
    "And you can use the fonts usually used in HTML.\n",
    "## Displaying Images (Only GIF)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "15027eb3-8314-4a93-a42d-6262b681690b",
   "metadata": {},
   "outputs": [
    {
     "ename": "TclError",
     "evalue": "image \"pyimage1\" doesn't exist",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTclError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_1308/2760480648.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[0mcanvas\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpack\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[0;32m      5\u001b[0m \u001b[0mmyImage\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mPhotoImage\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfile\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'C:\\\\Users\\\\icoes\\\\Desktop\\\\Giraffe.gif'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 6\u001b[1;33m \u001b[0mcanvas\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcreate_image\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0manchor\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mNW\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mimage\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmyImage\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32mC:\\Program Files\\WindowsApps\\PythonSoftwareFoundation.Python.3.10_3.10.240.0_x64__qbz5n2kfra8p0\\lib\\tkinter\\__init__.py\u001b[0m in \u001b[0;36mcreate_image\u001b[1;34m(self, *args, **kw)\u001b[0m\n\u001b[0;32m   2817\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mcreate_image\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkw\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[0;32m   2818\u001b[0m         \u001b[1;34m\"\"\"Create image item with coordinates x1,y1.\"\"\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 2819\u001b[1;33m         \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_create\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'image'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkw\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   2820\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2821\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mcreate_line\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkw\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[1;32mC:\\Program Files\\WindowsApps\\PythonSoftwareFoundation.Python.3.10_3.10.240.0_x64__qbz5n2kfra8p0\\lib\\tkinter\\__init__.py\u001b[0m in \u001b[0;36m_create\u001b[1;34m(self, itemType, args, kw)\u001b[0m\n\u001b[0;32m   2803\u001b[0m         \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2804\u001b[0m             \u001b[0mcnf\u001b[0m \u001b[1;33m=\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[1;32m-> 2805\u001b[1;33m         return self.tk.getint(self.tk.call(\n\u001b[0m\u001b[0;32m   2806\u001b[0m             \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_w\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'create'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mitemType\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2807\u001b[0m             *(args + self._options(cnf, kw))))\n",
      "\u001b[1;31mTclError\u001b[0m: image \"pyimage1\" doesn't exist"
     ]
    }
   ],
   "source": [
    "from tkinter import *\n",
    "tk = Tk()\n",
    "canvas = Canvas(tk, width=2698, height=3807)\n",
    "canvas.pack()\n",
    "myImage = PhotoImage(file = 'C:\\\\Users\\\\icoes\\\\Desktop\\\\Giraffe.gif')\n",
    "canvas.create_image(0, 0, anchor=NW, image=myImage)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "438e7f89-be98-4da3-85d8-7424c67be2c2",
   "metadata": {},
   "source": [
    "## Creating Animations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "abd38a26-f8e0-4baf-a8c1-41770b338735",
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "from tkinter import *\n",
    "tk = Tk()\n",
    "canvas = Canvas(tk, width=400, height=200)\n",
    "canvas.pack()\n",
    "canvas.create_polygon(10, 10, 10, 60, 50, 35)\n",
    "for x in range(0, 60):\n",
    "    canvas.move(1, 5, 0)\n",
    "    tk.update()\n",
    "    time.sleep(0.05)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "118947fd-948b-4c39-bf80-d9695a6c3a81",
   "metadata": {},
   "source": [
    "And you'd see a triangle moving across the screen. The `canvas.move` funtion will move any drawn object on the screen by adding the distance to the coordinates. The numbers represent the object with the corresponding ID, the increase in the x-axis and y-axis respectively. The `tk.update` updates the screen, causing the triangle to move every loop, instead of in the loop. The `time.sleep` function tells Python to wait before continuing. And this lets us see the animation, or else Python would make the animation to quick for us to see."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "30f645c0-40f8-4f3a-8cb4-0236bfd1db9d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "from tkinter import *\n",
    "tk = Tk()\n",
    "canvas = Canvas(tk, width=400, height=400)   \n",
    "canvas.pack()\n",
    "canvas.create_polygon(10, 10, 10, 60, 50, 35)\n",
    "for x in range(0, 180): \n",
    "    canvas.move(1, 1.666666666666667, 1.666666666666667)\n",
    "    tk.update()\n",
    "    time.sleep(0.0166666666666667)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7077e27-d81e-431c-a4fe-13888b4bca99",
   "metadata": {},
   "source": [
    "Here, we increased the height of the canvas and made the triangle move down every loop. Thus, the triangle will move down diagonally. With our geek skills, we made it match our device's refresh rate. You can even make the triangle move backwards!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "14d72942-7fd4-410d-b0fe-6c12f4651968",
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in range(0, 180):\n",
    "    canvas.move(1, -1.666666666666667, -1.666666666666667)\n",
    "    tk.update()\n",
    "    time.sleep(0.0166666666666667)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ad4ce9b-5ba4-444f-b742-288ea92ff6eb",
   "metadata": {},
   "source": [
    "Cool! After restarting the browser, tkinter is finally letting us draw!\n",
    "## Making an Object React To Something"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "88d621b8-5774-404f-b5cf-4c5651effee6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def moveIt(event):\n",
    "    canvas.move(1, 5, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acf1a9e4-4a4f-40bc-a430-b8299a012ef2",
   "metadata": {},
   "source": [
    "The parameter `event` is used by `tkinter` to send information to the function about the event. Remember when we learnt Scratch in P3 and the instructor always told us, \"Events first!\"? This is the same thing. We specify which event must take place in order that the function would run by using the `bind_all` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b5645f95-e61e-44dd-a553-917684225d45",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2530841683712movetriangle'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from tkinter import *\n",
    "tk = Tk()\n",
    "canvas = Canvas(tk, width=400, height=400)\n",
    "canvas.pack()\n",
    "canvas.create_polygon(10, 10, 10, 60, 50, 35)\n",
    "def movetriangle(event):\n",
    "    canvas.move(1, 5, 0)\n",
    "canvas.bind_all('<KeyPress-Return>', movetriangle)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e743dde-5d01-4516-9cff-e953259aa782",
   "metadata": {},
   "source": [
    "So `tkinter` watches out for the `keypress` of `return` or `enter`. Let's see what happens when we press enter. Nothing?! Well, we actually have to keep the tk window in the foreground.\n",
    "\n",
    "Cool!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "91ffac35-ef80-49ca-b553-47b1cc59d36f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def response():\n",
    "    def eventual(event):\n",
    "        if event.keysym == 'Up':\n",
    "            canvas.move(1, 0, -3)\n",
    "        elif event.keysym == 'Down':\n",
    "            canvas.move(1, 0, 3)\n",
    "        elif event.keysym == 'Left':\n",
    "            canvas.move(1, -3, 0)\n",
    "        else:\n",
    "            canvas.move(1, 3, 0)\n",
    "    canvas.bind_all('<KeyPress-Up>', movetriangle)\n",
    "    canvas.bind_all('<KeyPress-Down>', movetriangle)\n",
    "    canvas.bind_all('<KeyPress-Left>', movetriangle)\n",
    "    canvas.bind_all('<KeyPress-Right>', movetriangle)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "211b2a55-69ec-4e0e-8ab0-2d1309b94900",
   "metadata": {
    "tags": []
   },
   "source": [
    "Cool! The `kysym` variable means key symbol! The reason we did not have to specify the event when the right key is pressed is because there are no ohter keys under `kysym`! And we just created a character that you can move!\n",
    "## More Ways to Use the Identifier\n",
    "which is the ID of the object!\n",
    "\n",
    "A problem with"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "4d1d519c-d813-46a2-88e1-dcc666b6ebf4",
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> from tkinter import *\n",
    ">>> tk = Tk()\n",
    ">>> canvas = Canvas(tk, width=400, height=400)\n",
    ">>> canvas.pack()\n",
    ">>> canvas.create_polygon(10, 10, 10, 60, 50, 35)\n",
    "1\n",
    ">>> canvas.move(1, 5, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30272f39-8e48-48cc-86b5-a78d0a5be7c2",
   "metadata": {},
   "source": [
    "is that creating an object will not always return 1 as the ID. But, there is a workaround if you want to make a reusable function!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "f87e01fa-7a24-4859-8c61-1435a821b2fe",
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> mytriangle = canvas.create_polygon(10, 10, 10, 60, 50, 35)\n",
    ">>> canvas.move(mytriangle, 5, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c7a0bc0-9136-4c51-ab27-eb709bfaffd3",
   "metadata": {},
   "source": [
    "`mytriangle` basically contains the ID of the polygon created. Hence, there will not be any issues with the number of old figures affecting the ID of the new figure.\n",
    "\n",
    "The itemconfig function helps change the parameters of a shape, such as its fill and outline colors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "226355f8-8a28-46d5-968b-d641b406b131",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "tk = Tk()\n",
    "canvas = Canvas(tk, width=400, height=400)\n",
    "canvas.pack()\n",
    "mytriangle = canvas.create_polygon(10, 10, 10, 60, 50, 35, \n",
    "fill='red')\n",
    "canvas.itemconfig(mytriangle, fill='blue')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb3fab6b-1a58-4eef-b664-05aa0df20e21",
   "metadata": {},
   "source": [
    "Boom! The color just changes!\n",
    "## Challenges\n",
    "### Spam Triangles, in a Colorful Way!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "38334a46-c997-48ad-87a3-a668c0a195b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "from tkinter import *\n",
    "tk = Tk()\n",
    "canvas = Canvas(tk, width = 400, height = 400)\n",
    "canvas.pack()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "0f9aa34e-d443-40a5-9e38-f9f8c7f42ca7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def spam(width, height, fill_color):\n",
    "    x1 = random.randrange(width)\n",
    "    y1 = random.randrange(height)\n",
    "    x2 = random.randrange(width)\n",
    "    y2 = random.randrange(height)\n",
    "    x3 = random.randrange(width)\n",
    "    y3 = random.randrange(height)\n",
    "    canvas.create_polygon(x1, y1, x2, y2, x3, y3, fill = fill_color)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "4cf85285-fe8a-4af3-98b8-50ac57a784ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "def artsy():\n",
    "    amt = int(input('How many triangles would you like? ' ))\n",
    "    color = input('Would you like this artwork to be colorful? [y/n] ')\n",
    "    if color == 'y':\n",
    "        colors = ['green', 'red', 'blue', 'orange', 'yellow', 'pink', 'purple', 'violet', 'magenta', 'cyan']\n",
    "        for x in range(0, amt):\n",
    "            spam(400, 400, random.choice(colors))\n",
    "    if color == 'n':\n",
    "        color2 = input('What colour would you like all the triangles to be? You may enter a hex code. ')\n",
    "        for x in range(0, amt):\n",
    "            spam(400, 400, color2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "d547ca86-e719-4069-9fb0-383683756894",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "How many triangles would you like?  40\n",
      "Would you like this artwork to be colorful? [y/n]  y\n"
     ]
    }
   ],
   "source": [
    "artsy()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30bd1f61-7049-402c-8f81-c894f1d54855",
   "metadata": {},
   "source": [
    "Boom! We get a beautiful artwork!\n",
    "# Creating Games\n",
    "## Bounce (from Nokia)\n",
    "using `tkinter`! First, we have to create the game canvas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e0c7c70f-f322-4f86-bed9-f1d213460ad4",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "import random\n",
    "import time\n",
    "tk = Tk()\n",
    "tk.title(\"Game\")\n",
    "tk.resizable(0, 0)\n",
    "tk.wm_attributes(\"-topmost\", 1)\n",
    "canvas = Canvas(tk, width=500, height=400, bd=0, highlightthickness=0)\n",
    "canvas.pack()\n",
    "tk.update()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63b715ab-1b7d-4eee-a468-81cf76a99bdf",
   "metadata": {
    "tags": []
   },
   "source": [
    "What's going on here?!\n",
    "We inmported `random` and `time` for use later. Then, we titled the `tkinter` window 'Game'. Then, we used `resizable` to make the window a fixed size. The parameters `0, 0` say “the size of the window cannot be changed either horizontally or vertically.” Next, we call `wm_attributes` to tell `tkinter` to place \n",
    "the window containing our canvas in front of all other windows \n",
    "(`\"-topmost\"`). When we created a canvas object, we added in more parameters. Both `bd=0` and `highlightthickness=0` make sure that there’s no border around the outside of the canvas. FYI, `canvas.pack` tells the canvas to size itself according to the width and height parameters given in the preceding (previous) line. `tk.update` makes `tkinter` initialise itself for animations.\n",
    "## Creating the Ball Class\n",
    "is one of the use cases for classes."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "917c9d0d-c5d3-496e-9553-0b16c15b0095",
   "metadata": {},
   "source": [
    "    class Ball:\n",
    "        def __init__(self, canvas, color):\n",
    "            self.canvas = canvas\n",
    "            self.id = canvas.create_oval(10, 10, 25, 25, fill=color)\n",
    "            self.canvas.move(self.id, 245, 100)\n",
    "        def draw(self):\n",
    "            pass  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "96bc0b34-33cf-48e7-8547-12e6672b2c30",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Ball:\n",
    "    def __init__(self, canvas, color):\n",
    "        self.canvas = canvas\n",
    "        self.id = canvas.create_oval(10, 10, 25, 25, fill=color)\n",
    "        self.canvas.move(self.id, 245, 100)\n",
    "    def draw(self):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "342258ab-7fa5-4ee1-bb72-15b206cc21cb",
   "metadata": {},
   "source": [
    "This has to be added after the third line in the previous code. We named our class Ball at line 1. Then, we created an initialisation function which takes the parameters `canvas` and `color` at line 2. Then, we set the object variable `canvas` to the value of the parameter `canvas`. Then, we create an oval (or ball) at line 4. We store the variable `id` for the oval. In line 5, we move the oval to the centre of the canvas. Then, we define `draw(self)` and pass it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f44838bb-ebfa-4203-a1ad-9c4a5644ac54",
   "metadata": {},
   "outputs": [],
   "source": [
    "ball = Ball(canvas, 'red')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3314e95-a027-4400-a429-976b7c6dc167",
   "metadata": {},
   "source": [
    "This creates a ball. Boom! Then, we have to create an animation loop, called the main loop. It is the central part of a progam that controls what it does. For now, it only has to redraw the screen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "273a8ba8-de78-4a22-91b9-9d521682e15f",
   "metadata": {},
   "outputs": [],
   "source": [
    "while 1:\n",
    "    tk.update_idletasks()\n",
    "    tk.update()\n",
    "    time.sleep(0.01)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "720b0810-d917-4700-941d-80d21b8f7fb8",
   "metadata": {},
   "source": [
    "And this loop will run forever!\n",
    "### Making the Ball Move\n",
    "by changing the draw function by replacing `pass` with `self.canvas.move(self.id, 0, -1)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "68e7cbc8-8821-4720-8cb3-7c0a102d6837",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Ball:\n",
    "    def __init__(self, canvas, color):\n",
    "        self.canvas = canvas\n",
    "        self.id = canvas.create_oval(10, 10, 25, 25, fill=color)\n",
    "        self.canvas.move(self.id, 245, 100)\n",
    "    def draw(self):\n",
    "        self.canvas.move(self.id, 0, -1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79136fe8-779e-483a-afea-fb39c9425f9f",
   "metadata": {},
   "source": [
    "BREAKING NEWS!!! WE ARE SPLITTING THIS PYTHON NOTEBOOK INTO TWO OF THEM. The first one, named 'exploration' will be mainly for trying out new pieces of code from Python for Kids. We will not be using markdown that much. Instead of just copy-pasting everything, we will be writing down our thoughts on each cell of code. The second Notebook, named 'applications', will be used for our own applications using our knowledge. Here, we may jot down some useful codes, attempt challenges from Python for Kids and more. It will be mainly for our own 'entertaintment'. So, this will be the cell of this Notebook. Farewell!"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}