python103_classes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "source": [
    "# Classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "So far we have seen data and functions. Data which is the information, functions which are the actions that manipulate, interact with and present that information."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Classes are a new kind of code container, a different kind of way to structure our code. Classes enable us to make computer representations of concepts and ideas. Classes do not distinguish so clearly between data and behaviour. Let's consider what this would look like in code:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Functions and Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "tasks = {}\n",
    "\n",
    "def add_todo():\n",
    "    ''''''\n",
    "    \n",
    "def remove_todo():\n",
    "    ''''''\n",
    "    \n",
    "def list_todos():\n",
    "    ''''''\n",
    "    \n",
    "def complete_todo():\n",
    "    ''''''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "class TodoList(object):\n",
    "    \n",
    "    TASKS = {}\n",
    "    \n",
    "    def add_todo(self):\n",
    "        ''''''\n",
    "        \n",
    "    def remove_todo(self):\n",
    "        ''''''\n",
    "        \n",
    "    def remove_todo(self):\n",
    "        ''''''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "We could easily write our function based app using classes!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# Why Classes?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "To associate behaviour with data. To structure our code in an alternative way. To begin programming with `Objects`. To represent concepts as code.\n",
    "\n",
    "With classes we can begin programming in an **Object Oriented** way. This requires a different way to thinking about our code design. Our current Todo App is designed to highlight the data which we capture in a dictionary. With classes we can instead begin to think with ideas instead of raw data. Rather than data, we will think of the key concepts of the Todo App - the `TodoList` and the `Task`. We will now think about our `TodoList`, which is comprised of many `Tasks`. The `TodoList` and `Task` are independent entities and have different associated behaviour.\n",
    "\n",
    "> With functions we consider, '*what actions can my functions perform on data?*'\n",
    "\n",
    "> With classes we consider, '*what actions can my concepts/ideas/objects/classes perform?*'\n",
    "\n",
    "We no longer distinguish between function and form! Now data and functions are **encapsulated** together, classes contain both."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### Benefits of Classes:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "- Structure\n",
    "- Labels\n",
    "- Interfaces/Data hiding\n",
    "- SOLID\n",
    "- Encapsulation\n",
    "- Inheritance \n",
    "- Polymorphism"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## How to use classes?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "class TodoList(object):\n",
    "    \n",
    "    TASKS = {}\n",
    "    \n",
    "    def add_task(self, task):\n",
    "        ''''''\n",
    "        \n",
    "class Task(object):\n",
    "\n",
    "    def __init__(self, description):\n",
    "        ''''''\n",
    "\n",
    "my_todo_list = TodoList()\n",
    "my_first_task = Task('learn about classes')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Using classes requires one more step than independent functions. Classes have to first be created. Class creation is often called **instantiation** - which means we are taking our *idea* and creating an active version within the computer.\n",
    "\n",
    "When classes are created it is often useful to pass data to them:\n",
    "\n",
    "```\n",
    "class Task(object):\n",
    "\n",
    "    def __init__(self, description):\n",
    "        ...\n",
    "\n",
    "my_first_task = Task('learn about classes')\n",
    "```\n",
    "\n",
    "This is particularly useful when you realise we can create multiple versions of classes at any time!\n",
    "\n",
    "```\n",
    "class Task(object):\n",
    "\n",
    "    def __init__(self, description):\n",
    "        ...\n",
    "\n",
    "my_first_task = Task('learn about classes')\n",
    "second_task = Task('conduct workshop')\n",
    "```\n",
    "\n",
    "We can create one or many versions of classes. There is no limit. Some classes, like `Task()` will need to be created a lot, while our `TodoList()` probably only needs one version.\n",
    "\n",
    "Next we need to know how to add behaviour and data to our classes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "We can add functions to classes. They will look very similar to regular functions. To ensure there is no confusion, functions that are within classes are often called **methods**. The main difference between a function and method is that we access them in a different way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "print from within a class\n",
      "print in a function\n"
     ]
    }
   ],
   "source": [
    "class PrintClass(object):\n",
    "\n",
    "    def print_stuff(self, message):\n",
    "        print(message)\n",
    "        \n",
    "def print_function(message):\n",
    "    print(message)\n",
    "    \n",
    "print_class = PrintClass()\n",
    "print_class.print_stuff('print from within a class')\n",
    "\n",
    "print_function('print in a function')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "The power is that now our classes have responsibility for their behaviour - it is the class *performing* the behaviour, we are giving our *idea* life!\n",
    "\n",
    "For this workshop, we want to create a `TodoList()` class. That class should have all the behaviour we expect a todo list to have! Like adding, removing, and presenting tasks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### Class data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Classes can store their own data. This is useful because we can create many versions of our classes, and each one can have different data. We interact with a class versions data through the keyword `self`. Try the following example for yourself - don't forget to change and experiment with a few things:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "understand class data\n",
      "now I get it!\n"
     ]
    }
   ],
   "source": [
    "class Task(object):\n",
    "    \n",
    "    def __init__(self, description):\n",
    "        self.description = description # save the task description on the task itself!\n",
    "        \n",
    "    def print_description(self):\n",
    "        print(self.description) # we can now use that data in the class methods\n",
    "        \n",
    "    def edit_description(self, description):\n",
    "        self.description = description\n",
    "        return self.description\n",
    "    \n",
    "my_task = Task('understand class data')\n",
    "my_task.print_description()\n",
    "my_task.edit_description('now I get it!')\n",
    "my_task.print_description()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Recap:\n",
    "\n",
    "- We must create, or **instaniate**, classes before using them\n",
    "- Class functions are called methods\n",
    "- Use the `__init__` method to add class data at creation time\n",
    "- Save and access class data using the `self` keyword"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "source": [
    "Here's the plan. Rewrite the core of your function only Todo App using classes!\n",
    "\n",
    "**The goal**: the two versions of the app should be indestinguishable to the user."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "source": [
    "# 1) Complete the following class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "class TodoList(object):\n",
    "    \n",
    "    TASKS = {}\n",
    "    \n",
    "    def add_task(self, description, category):\n",
    "        '''\n",
    "        >>> todo_list = TodoList()\n",
    "        >>> todo_list.add_task('describe how tasks work', 'teaching')\n",
    "        >>> todo_list.TASKS['teaching']\n",
    "        {\n",
    "            'teaching': {\n",
    "                'done': []\n",
    "                'todo': ['describe how tasks work']\n",
    "        }\n",
    "        '''\n",
    "        pass\n",
    "    \n",
    "    def create_category(self, category):\n",
    "        '''\n",
    "        >>> todo_list = TodoList()\n",
    "        >>> todo_list.create_category('teaching')\n",
    "        >>> todo_list.create_category('teaching')\n",
    "        >>> todo_list.TASKS['teaching']\n",
    "        {\n",
    "            'teaching': {\n",
    "                'done': []\n",
    "                'todo': []\n",
    "        }\n",
    "        '''\n",
    "        pass\n",
    "    \n",
    "    def get_categories(self):\n",
    "        '''\n",
    "        >>> todo_list = TodoList()\n",
    "        >>> todo_list.create_category('teaching')\n",
    "        >>> todo_list.create_category('programming')\n",
    "        >>> todo_list.get_categories()\n",
    "        ['teaching', 'programming']\n",
    "        '''\n",
    "        pass\n",
    "    \n",
    "    def filter_by_category(self, category):\n",
    "        '''\n",
    "        >>> todo_list = TodoList()\n",
    "        >>> todo_list.create_category('teaching')\n",
    "        >>> todo_list.create_category('programming')\n",
    "        >>> todo_list.add_task('describe how tasks work', 'teaching')\n",
    "        >>> todo_list.add_task('learn about Python classes', 'programming')\n",
    "        >>> todo_list.filter_by_category('programming')\n",
    "        {\n",
    "            'programming': {\n",
    "                'done': []\n",
    "                'todo': ['learn about Python classes']\n",
    "        }\n",
    "        '''\n",
    "        pass\n",
    "    \n",
    "    def complete_task(category, task_id):\n",
    "        '''\n",
    "        >>> todo_list = TodoList()\n",
    "        >>> todo_list.create_category('programming')\n",
    "        >>> todo_list.add_task('learn about Python classes', 'programming')\n",
    "        >>> todo_list.complete_task('programming', 0)\n",
    "        {\n",
    "            'programming': {\n",
    "                'done': ['learn about Python classes']\n",
    "                'todo': []\n",
    "        }\n",
    "        '''\n",
    "        pass\n",
    "    \n",
    "    def delete_task(category, task_id):\n",
    "        '''\n",
    "        >>> todo_list = TodoList()\n",
    "        >>> todo_list.create_category('programming')\n",
    "        >>> todo_list.add_task('learn about Python classes', 'programming')\n",
    "        >>> todo_list.delete_task('programming', 0)\n",
    "        {\n",
    "            'programming': {\n",
    "                'done': []\n",
    "                'todo': []\n",
    "        }\n",
    "        '''\n",
    "        pass\n",
    "    \n",
    "    def show_all_tasks(self):\n",
    "        '''\n",
    "        >>> todo_list = TodoList()\n",
    "        >>> todo_list.create_category('teaching')\n",
    "        >>> todo_list.create_category('programming')\n",
    "        >>> todo_list.add_task('describe how tasks work', 'teaching')\n",
    "        >>> todo_list.add_task('learn about Python classes', 'programming')\n",
    "        >>> todo_list.show_all_tasks()\n",
    "        {\n",
    "           'teaching': {\n",
    "                'done': []\n",
    "                'todo': ['describe how tasks work']\n",
    "            'programming': {\n",
    "                'done': []\n",
    "                'todo': ['learn about Python classes']\n",
    "        }\n",
    "        '''\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Test your changes directly here!\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### CLI\n",
    "\n",
    "Test your changes with the following CLI implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    " def add_task(todo_list):\n",
    "    category, description, priority = get_category_task_and_priority_from_user()\n",
    "    todo_list.create_category(category)\n",
    "    todo_list.add_task(description, category, priority)\n",
    "\n",
    "def get_category_task_and_priority_from_user():\n",
    "    category = input('Enter a task category \\n')\n",
    "    task = input('Enter a task \\n')\n",
    "#     priority = input('What is this tasks priority? (Enter \"low\" or \"high\") ')\n",
    "    return category, task\n",
    "\n",
    "def manage_tasks(todo_list):\n",
    "    while True:\n",
    "        USER_ACTION_PROMPT = 'Either select a category, or type \"exit\" to return to the previous menu. \\n'\n",
    "        category = input(USER_ACTION_PROMPT + todo_list.get_categories())\n",
    "        if category == 'exit': break\n",
    "        manage_category(todo_list, category)\n",
    "\n",
    "def manage_category(todo_list, category):\n",
    "    USER_ACTION_PROMPT = '''Press (1) to view all tasks\n",
    "Press (2) to mark a task complete\n",
    "Press (3) to delete a task\n",
    "Press (4) to exit to the previous menu\n",
    "'''\n",
    "    while True:\n",
    "        user_action = input(USER_ACTION_PROMPT)\n",
    "        if user_action == '1':\n",
    "            print(todo_list.filter_by_category(category))\n",
    "        elif user_action == '2':\n",
    "            task_id = input('Enter a task number to complete task \\n')\n",
    "            todo_list.complete_task(category, task_id)\n",
    "        elif user_action == '3':\n",
    "            task_id = input('Enter a task number to delete task \\n')\n",
    "            todo_list.delete_task(category, task_id)\n",
    "        elif user_action == '4':\n",
    "            break\n",
    "        else:\n",
    "            print('Invalid input, please select again.')\n",
    "\n",
    "USER_ACTION_PROMPT = '''Press (1) to add a task\n",
    "Press (2) to manage tasks\n",
    "Press (3) to exit\n",
    "'''\n",
    "\n",
    "def run_program():\n",
    "    todo_list = TodoList()\n",
    "    while True:\n",
    "        user_action = input(USER_ACTION_PROMPT)\n",
    "        if user_action == '1':\n",
    "            todo_dict = add_task(todo_list)\n",
    "        elif user_action == '2':\n",
    "            manage_tasks(todo_list)\n",
    "        elif user_action == '3':\n",
    "            break\n",
    "        else:\n",
    "            print('Invalid input, please select again.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "run_program()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# A Classy Interlude!\n",
    "\n",
    "Until this point our 'tasks' have been simple strings. Considering tasks are such a critical component in our todo app, could we describe them using classes too?\n",
    "\n",
    "Consider the following implementation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "from datetime import datetime\n",
    "\n",
    "class Task(object):\n",
    "    priority = 3\n",
    "\n",
    "    def __init__(self, description, category):\n",
    "        self.description = description\n",
    "        self.category = category\n",
    "        self.created_date = datetime.now()\n",
    "        self.completed_date = None\n",
    "\n",
    "    def complete_task(self):\n",
    "        self.completed_date = datetime.now()\n",
    "\n",
    "    def is_task_complete(self):\n",
    "        return self.complete != None\n",
    "\n",
    "    def get_priority():\n",
    "        return self.priority\n",
    "\n",
    "    def __repr__(self):\n",
    "        return '<< Low Priority Task: {} >>'.format(self.description)\n",
    "\n",
    "\n",
    "class HighPriorityTask(Task):\n",
    "    priority = 5\n",
    "\n",
    "    def __repr__(self):\n",
    "        return '<< HIGH PRIORITY TASK: {} >>'.format(self.description)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "How can we use this `Task()` class to add more behaviour and information to each task that is stored in the todo list?\n",
    "\n",
    "It is not wrong to say that classes are also a form of data. So where we can store a string, we can almost always store a class. Using the `Task()` class allows us a little freedom to alter the structure of our todo list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Let's explore how leverging more classes to structure, organise and compartmentalise behaviour and data can add new dimensions to our app."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "class TodoList(object):\n",
    "    \n",
    "    TASKS = []\n",
    "    \n",
    "    def add_task(self, description, category):\n",
    "        '''\n",
    "        >>> todo_list = TodoList()\n",
    "        >>> todo_list.add_task('classes inside of claasses!', 'teaching')\n",
    "        >>> todo_list.TASKS\n",
    "        [<< Low Priority Task: classes inside of claasses! >>]\n",
    "        ''' \n",
    "        task = Task(description, category)\n",
    "        self.TASKS.append(task)\n",
    "    \n",
    "    def create_category(self, category):\n",
    "        '''\n",
    "        do we need this anymore?\n",
    "        '''\n",
    "        pass\n",
    "    \n",
    "    def get_categories(self):\n",
    "        '''\n",
    "        You will need to use a `for` loop. \n",
    "        How can we make sure only one category string is returned for each category?\n",
    "        '''\n",
    "        pass\n",
    "    \n",
    "    def filter_by_category(self, category):\n",
    "        '''\n",
    "        https://docs.python.org/3/library/functions.html#filter\n",
    "        '''\n",
    "        pass\n",
    "    \n",
    "    def complete_tasks(task_id):\n",
    "        '''\n",
    "        We no longer need to move the task, or find its category!\n",
    "        '''\n",
    "    \n",
    "    def delete_task(task_id):\n",
    "        pass\n",
    "    \n",
    "    def show_all_tasks(self):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "**Bonus Round**:\n",
    "\n",
    "1) Find the `HighPriorityTask` above. This is an example of class inheritence. Where could this class be used in our app?\n",
    "\n",
    "2) Why not use the `priority` class value directly? Why create an entirely new class? (Bug the instructor about this if there is time!)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# Conclusion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Today you have been exposed to the largest, most flexible and most difficult building blocks you can use in your code. The goal was to help give you an intuition about functions, modules and classes. The theory, however, was glossed over and should be treated as a homework exercise for you! Don't take our word for it, go discover why functions, classes and modularity are considered important!\n",
    "\n",
    "Feel free to reach out to me on social media:\n",
    "\n",
    "https://www.linkedin.com/in/aaronmyatt/\n",
    "\n",
    "https://www.facebook.com/barry.ington\n",
    "\n",
    "Find these notebooks on Github:\n",
    "\n",
    "https://github.com/aaronmyatt/wwc-python103"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}