notebooks/Introduction_to_Python_3_Classes_chapter.ipynb

{"nbformat": 4, "nbformat_minor": 0, "metadata": {"colab": {"name": "Introduction_to_Python_3_Classes_chapter.ipynb", "provenance": [], "collapsed_sections": ["0ZEC4V3pjalH", "FrOuZWcdbkyh", "23NhvjOzSlu4", "Zb4bybUiS3qz", "At7-_WM6bn6A", "xFAS-L5uZtff", "IyTNBT8sh-UE", "8USdvrcJvk9n", "PNT4q5Ks7v79", "xNpgmyOd0gHR", "iPp6yJhCApcR", "vDyUpa7_L54U", "dRtVOqsBC4AJ", "v3CGE72REsXJ"]}, "kernelspec": {"name": "python3", "display_name": "Python 3"}}, "cells": [{"cell_type": "markdown", "metadata": {"id": "1Ycy34VcX4lu"}, "source": ["# Introduction to Python 3: Classes\n", "## Luca de Alfaro\n", "Copyright Luca de Alfaro, 2018-21.  CC-BY-NC License.\n"]}, {"cell_type": "markdown", "metadata": {"id": "7f54d24de2424549", "colab_type": "text"}, "source": "\nPrepared on: Tue Aug  3 11:56:46 2021\n\nThis is a book chapter; it is not a homework assignment.  \nDo not submit it as a solution to a homework assignment; you would receive no credit.\n"}, {"cell_type": "markdown", "metadata": {"id": "v3CGE72REsXJ"}, "source": ["## Classes"]}, {"cell_type": "markdown", "metadata": {"id": "k9fPFYIBtf9S"}, "source": ["Here is a simple example of a class declaration.\n"]}, {"cell_type": "code", "metadata": {"id": "hlRW5aLu32sp"}, "source": ["class Product(object):\n", "\n", "    def __init__(self, name, price=0., quantity=0):\n", "        \"\"\"In the initializer, you should define the values that each object\n", "        has.  Here, 'self' means, the object.\"\"\"\n", "        self.name = name\n", "        self.price = price\n", "        self.quantity = quantity\n"], "execution_count": 12, "outputs": []}, {"cell_type": "markdown", "metadata": {"id": "lBmr9u6734YW"}, "source": ["I can then define a list of products: "]}, {"cell_type": "code", "metadata": {"id": "lzns-MqK39bG"}, "source": ["cart = [\n", "    Product('Pear', price=1.99, quantity=10),\n", "    Product('Apple', price=0.99, quantity=15),\n", "    Product('Onion', price=1.49, quantity=57)\n", "]\n"], "execution_count": 13, "outputs": []}, {"cell_type": "code", "metadata": {"id": "kUyevv1p3_aw"}, "source": ["for p in cart:\n", "    print(\"The price of\", p.name, \"is\", p.price)\n"], "execution_count": 14, "outputs": [{"output_type": "stream", "text": ["The price of Pear is 1.99\n", "The price of Apple is 0.99\n", "The price of Onion is 1.49\n"], "name": "stdout"}]}, {"cell_type": "markdown", "metadata": {"id": "03hgqa0h4GOj"}, "source": ["You can add _methods_ to a class, which enable you to operate on the objects: "]}, {"cell_type": "code", "metadata": {"id": "QkYwW8lIEc1M"}, "source": ["class Product(object):\n", "\n", "    def __init__(self, name, price=0., quantity=0):\n", "        \"\"\"In the initializer, you should define the values that each object\n", "        has.  Here, 'self' means, the object.\"\"\"\n", "        self.name = name\n", "        self.price = price\n", "        self.quantity = quantity\n", "\n", "    def __repr__(self):\n", "        \"\"\"Represents a class element in a reasonable way.\n", "        Note the format statement below to help produce a string.\"\"\"\n", "        return \"Hello, I am a {} and cost ${}; you have {} of me\".format(\n", "            self.name, self.price, self.quantity\n", "        )\n", "\n", "    def inflation(self, x):\n", "        \"\"\"Increases the price by a factor x.\n", "        Note how self is always the first argument of methods; otherwise,\n", "        you would not know to which object to apply the operations.\"\"\"\n", "        self.price *= x\n", "\n", "    @property\n", "    def value(self):\n", "        \"\"\"Total value of products of this type.\"\"\"\n", "        return self.price * self.quantity\n", "\n"], "execution_count": 15, "outputs": []}, {"cell_type": "markdown", "metadata": {"id": "boxJLWV0tlZz"}, "source": ["The `@property` above enables us to write `p.value` rather than `p.value()` to get the value of a product in our inventory. "]}, {"cell_type": "code", "metadata": {"id": "YtVlHOVX7HRL"}, "source": ["p = Product('Pear', price=2, quantity=3)\n", "p.inflation(1.2)\n", "print(p.price)\n"], "execution_count": 16, "outputs": [{"output_type": "stream", "text": ["2.4\n"], "name": "stdout"}]}, {"cell_type": "code", "metadata": {"id": "Vjif1xPIOn3L"}, "source": ["cart = [\n", "    Product('Pear', price=1.99, quantity=10),\n", "    Product('Apple', price=0.99, quantity=15),\n", "    Product('Onion', price=1.49, quantity=57)\n", "]\n"], "execution_count": 17, "outputs": []}, {"cell_type": "code", "metadata": {"id": "fsSMHtXw4gDS"}, "source": ["for p in cart:\n", "    print(p.value)\n"], "execution_count": 18, "outputs": [{"output_type": "stream", "text": ["19.9\n", "14.85\n", "84.92999999999999\n"], "name": "stdout"}]}, {"cell_type": "markdown", "metadata": {"id": "OC_ngJfStnrs"}, "source": ["We can print the products; their representation is given by `__repr__`. \n"]}, {"cell_type": "code", "metadata": {"id": "A-np4oPXOmzG"}, "source": ["for p in cart:\n", "    print(p)\n"], "execution_count": 19, "outputs": [{"output_type": "stream", "text": ["Hello, I am a Pear and cost $1.99; you have 10 of me\n", "Hello, I am a Apple and cost $0.99; you have 15 of me\n", "Hello, I am a Onion and cost $1.49; you have 57 of me\n"], "name": "stdout"}]}, {"cell_type": "markdown", "metadata": {"id": "Qa6LYGwbttWq"}, "source": ["What if you buy more apples?  \n", "\n", "The proper way would be to define a buy method, and write \n", "something like `p.buy(10)` to buy 10 more.  But in Python, there is \n", "nothing to prevent you from accessing object variables directly.\n", "\n"]}, {"cell_type": "code", "metadata": {"id": "bqSkhbxMPYkz"}, "source": ["def double_the_cart(c):\n", "    for p in c:\n", "        p.quantity *= 2\n", "\n", "double_the_cart(cart)\n", "\n", "def print_cart(c):\n", "    for p in c:\n", "        print(p)\n", "\n", "print_cart(cart)\n"], "execution_count": 20, "outputs": [{"output_type": "stream", "text": ["Hello, I am a Pear and cost $1.99; you have 20 of me\n", "Hello, I am a Apple and cost $0.99; you have 30 of me\n", "Hello, I am a Onion and cost $1.49; you have 114 of me\n"], "name": "stdout"}]}, {"cell_type": "markdown", "metadata": {"id": "GiIDiPF-QqeS"}, "source": ["## A simple event-based simulator"]}, {"cell_type": "markdown", "metadata": {"id": "VXPul2nYSEjT"}, "source": ["Let's try to put everything together and design a simple event-based simulator. \n", "\n", "Every event will have a time at which it happens.  When it happens, it will generate two things: a string that is printed, and a list (possibly empty) of subsequent events. \n", "\n", "Let us write the code for three event types: one that occurs only once, one that occurs periodically with a certain delay between occurrences forever, and one that occurs periodically, but has a specified maximum number of occurrences.\n", "\n"]}, {"cell_type": "code", "metadata": {"id": "R6NcNyN-Qpda"}, "source": ["class GenericEvent(object):\n", "\n", "    def __init__(self, name, time):\n", "        self.name = name\n", "        self.time = time\n", "\n", "    def __repr__(self):\n", "        return \"Event {} of type {} will occurr at {}\".format(\n", "            self.name,\n", "            type(self),\n", "            self.time.isoformat()\n", "        )\n", "\n", "    def __lt__(self, other):\n", "        \"\"\"To sort events according to their time, we need to\n", "        implement the __lt__ operator.  This will be used by heapq later.\"\"\"\n", "        return self.time < other.time\n", "\n", "    def _effect(self):\n", "        \"\"\"In Python, methods that are supposed to be accessed only within\n", "        the class are prepended with _.  Note that this is just a convention;\n", "        nothing prevents you from calling these methods from outside the class.\n", "        \"\"\"\n", "        print(\"At {}: {}\".format(self.time.isoformat(), self.name))\n", "\n", "    def do(self):\n", "        \"\"\"You are supposed to define what happens in each subclass.\"\"\"\n", "        raise NotImplementedError()\n", "\n", "# We need the datetime module to process times.\n", "import datetime\n", "e = GenericEvent('Sun shines', datetime.datetime.now() + datetime.timedelta(hours=1))\n", "e\n"], "execution_count": 21, "outputs": [{"output_type": "execute_result", "data": {"text/plain": ["Event Sun shines of type <class '__main__.GenericEvent'> will occurr at 2021-08-03T19:40:48.604274"]}, "metadata": {"tags": []}, "execution_count": 21}]}, {"cell_type": "markdown", "metadata": {"id": "Sxnm49g99AYY"}, "source": ["The `__lt__` operator is needed to sort events; see [the sort HOWTO](https://docs.python.org/3/howto/sorting.html#odd-and-ends). "]}, {"cell_type": "markdown", "metadata": {"id": "QaTogCD1t9nA"}, "source": ["Let's define an event that happens once only.\n"]}, {"cell_type": "code", "metadata": {"id": "GOn2kj8OTlgG"}, "source": ["class OnceOnlyEvent(GenericEvent):\n", "    \"\"\"OnceOnlyEvent extends GenericEvent, and so it inherits all of its\n", "    methods, including __repr__, __comp__, _effect.\"\"\"\n", "\n", "    def do(self):\n", "        self._effect()\n", "        # No other events are generated.\n", "        return []\n"], "execution_count": 22, "outputs": []}, {"cell_type": "markdown", "metadata": {"id": "-9f0ErwtuB1n"}, "source": ["We can define periodic events, which occur forever with a given period: "]}, {"cell_type": "code", "metadata": {"id": "oU9pf8fwU9Gx"}, "source": ["class InfinitePeriodicEvent(GenericEvent):\n", "    \"\"\"This is a periodic event.\"\"\"\n", "\n", "    def __init__(self, name, time, periodicity):\n", "        \"\"\"time is a datetime object; periodicity is expressed as a timedelta object.\"\"\"\n", "        super().__init__(name, time)\n", "        self.periodicity = periodicity\n", "\n", "    def do(self):\n", "        self._effect()\n", "        # Generates and returns the next occurrence of the event.\n", "        next_event =InfinitePeriodicEvent(\n", "            self.name,\n", "            self.time + self.periodicity,\n", "            self.periodicity\n", "        )\n", "        return [next_event]\n", "\n"], "execution_count": 23, "outputs": []}, {"cell_type": "markdown", "metadata": {"id": "asRz7XyyuIbQ"}, "source": ["We can also define periodic events with a finite number of occurrences: you may be familiar with them from scheduling with calendars: "]}, {"cell_type": "code", "metadata": {"id": "JBDmQKy_WGiq"}, "source": ["class PeriodicEvent(GenericEvent):\n", "    \"\"\"This is a periodic event like above, except that it has\n", "    an optional maximum number of occurrences.\"\"\"\n", "\n", "    def __init__(self, name, time, periodicity, num_occurrences=None):\n", "        \"\"\"\n", "        Let's document this constructor a bit better.\n", "        @param name: name of the event.\n", "        @param time: time of first occurrence of the event (datetime object).\n", "        @param periodicity: periodicity of the event (timedelta object).\n", "        @param num_occurrences: number of future occurrences of the event.\n", "            If None, then infinite future occurrences can happen.\n", "\n", "        \"\"\"\n", "        assert num_occurrences is None or num_occurrences > 0\n", "        # We don't want to go back in time!\n", "        assert periodicity.total_seconds() > 0.\n", "        super().__init__(name, time)\n", "        self.periodicity = periodicity\n", "        self.num_occurrences = num_occurrences\n", "\n", "    def do(self):\n", "        self._effect()\n", "        # Generates and returns the next occurrence of the event.\n", "        if self.num_occurrences is None or self.num_occurrences > 1:\n", "            return [PeriodicEvent(\n", "                self.name,\n", "                self.time + self.periodicity,\n", "                self.periodicity,\n", "                num_occurrences = None if self.num_occurrences is None\n", "                                  else self.num_occurrences - 1\n", "            )]\n", "        else:\n", "            return []\n"], "execution_count": 24, "outputs": []}, {"cell_type": "markdown", "metadata": {"id": "paW7emunYCI8"}, "source": ["Great.  Now, let's define our discrete event simulator.  It will be a class, have a method to add new events to it, and it will have a method step(), which causes the next event to occur. \n", "\n", "In order to quickly determine which one is the next event, \n", "the best would be to use a [priority queue](https://docs.python.org/3/library/heapq.html).  For teh sake of simplicity, we will just keep a list of events softed according to time. "]}, {"cell_type": "code", "metadata": {"id": "QMKRcWMOX3dY"}, "source": ["class EventSimulator(object):\n", "\n", "    def __init__(self, event_list=None):\n", "        self.event_list = event_list or []\n", "        self.event_list.sort()\n", "\n", "    def add_event(self, e):\n", "        \"\"\"Adds an event e, maintaining the heap invariant.\"\"\"\n", "        self.event_list.append(e)\n", "        self.event_list.sort()\n", "\n", "    def step(self):\n", "        \"\"\"Performs one step of the event simulator.\"\"\"\n", "        # Gets the first event.\n", "        e = self.event_list.pop(0)\n", "        # Causes e to happen.\n", "        generated_events = e.do()\n", "        # And inserts the resulting events into the heap of future events.\n", "        for ge in generated_events:\n", "            self.add_event(ge)\n"], "execution_count": 25, "outputs": []}, {"cell_type": "markdown", "metadata": {"id": "egG1ha4duYg7"}, "source": ["That's all there is to it.  Now let's try how it works.\n", "We generate a couple of events that happen only once: \n"]}, {"cell_type": "code", "metadata": {"id": "-Va0ZFeOcnvy"}, "source": ["now = datetime.datetime.now()\n", "ten_secs = datetime.timedelta(seconds=10)\n", "twentyfive_secs = datetime.timedelta(seconds=25)\n", "\n", "once1 = OnceOnlyEvent(\"once1\", now + ten_secs)\n", "once2 = OnceOnlyEvent(\"once2\", now + twentyfive_secs)\n"], "execution_count": 26, "outputs": []}, {"cell_type": "markdown", "metadata": {"id": "wiXaR24NubdQ"}, "source": ["Let's also define two periodic events, one with 3 occurrences,\n", "the other with infinite occurrences.\n"]}, {"cell_type": "code", "metadata": {"id": "Ebb1lJlAdPdj"}, "source": ["two_secs = datetime.timedelta(seconds=2)\n", "three_secs = datetime.timedelta(seconds=3)\n", "\n", "periodic1 = PeriodicEvent(\"periodic1\", now + ten_secs, three_secs, num_occurrences=7)\n", "periodic2 = PeriodicEvent(\"periodic2\", now + twentyfive_secs, three_secs)\n"], "execution_count": 27, "outputs": []}, {"cell_type": "markdown", "metadata": {"id": "-nKqIiK3ufLv"}, "source": ["Let's create our event simulator. \n"]}, {"cell_type": "code", "metadata": {"id": "njwkT706eXLm"}, "source": ["sim = EventSimulator([once1, once2, periodic1, periodic2])\n"], "execution_count": 28, "outputs": []}, {"cell_type": "code", "metadata": {"id": "LsjIFxY-g3P7"}, "source": ["sim.step()\n"], "execution_count": 29, "outputs": [{"output_type": "stream", "text": ["At 2021-08-03T18:40:58.685097: once1\n"], "name": "stdout"}]}, {"cell_type": "markdown", "metadata": {"id": "4swatNPMuiHM"}, "source": ["What's in the event queue? \n"]}, {"cell_type": "code", "metadata": {"id": "JuNMeyDYiNFs"}, "source": ["sim.event_list\n"], "execution_count": 30, "outputs": [{"output_type": "execute_result", "data": {"text/plain": ["[Event periodic1 of type <class '__main__.PeriodicEvent'> will occurr at 2021-08-03T18:40:58.685097,\n", " Event once2 of type <class '__main__.OnceOnlyEvent'> will occurr at 2021-08-03T18:41:13.685097,\n", " Event periodic2 of type <class '__main__.PeriodicEvent'> will occurr at 2021-08-03T18:41:13.685097]"]}, "metadata": {"tags": []}, "execution_count": 30}]}, {"cell_type": "markdown", "metadata": {"id": "36Ne2hWKukaC"}, "source": ["Let's do 20 steps now.\n"]}, {"cell_type": "code", "metadata": {"id": "SpxS_5SYioUv"}, "source": ["for _ in range(20):\n", "    sim.step()\n", "sim.event_list\n"], "execution_count": 31, "outputs": [{"output_type": "stream", "text": ["At 2021-08-03T18:40:58.685097: periodic1\n", "At 2021-08-03T18:41:01.685097: periodic1\n", "At 2021-08-03T18:41:04.685097: periodic1\n", "At 2021-08-03T18:41:07.685097: periodic1\n", "At 2021-08-03T18:41:10.685097: periodic1\n", "At 2021-08-03T18:41:13.685097: once2\n", "At 2021-08-03T18:41:13.685097: periodic2\n", "At 2021-08-03T18:41:13.685097: periodic1\n", "At 2021-08-03T18:41:16.685097: periodic2\n", "At 2021-08-03T18:41:16.685097: periodic1\n", "At 2021-08-03T18:41:19.685097: periodic2\n", "At 2021-08-03T18:41:22.685097: periodic2\n", "At 2021-08-03T18:41:25.685097: periodic2\n", "At 2021-08-03T18:41:28.685097: periodic2\n", "At 2021-08-03T18:41:31.685097: periodic2\n", "At 2021-08-03T18:41:34.685097: periodic2\n", "At 2021-08-03T18:41:37.685097: periodic2\n", "At 2021-08-03T18:41:40.685097: periodic2\n", "At 2021-08-03T18:41:43.685097: periodic2\n", "At 2021-08-03T18:41:46.685097: periodic2\n"], "name": "stdout"}, {"output_type": "execute_result", "data": {"text/plain": ["[Event periodic2 of type <class '__main__.PeriodicEvent'> will occurr at 2021-08-03T18:41:49.685097]"]}, "metadata": {"tags": []}, "execution_count": 31}]}, {"cell_type": "markdown", "metadata": {"id": "GhXCeYkojMl9"}, "source": ["*That's All, Folks!*"]}]}