programming/5_Intro_to_OOP.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To open this notebook in Google Colab and start coding, click on the Colab icon below.\n",
    "<table style=\"border:2px solid orange\" align=\"left\">\n",
    "  <td style=\"border:2px solid orange \">\n",
    "    <a target=\"_blank\" href=\"https://colab.research.google.com/github/neuefische/ds-welcome-package/blob/main/programming/5_Intro_to_OOP.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" />Run in Google Colab</a>\n",
    "  </td>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# Introduction to Object-oriented programming\n",
    "\n",
    "In this notebook we will only cover a very superficial introduction, when you start to really program seriously do go beyond this lesson.\n",
    "\n",
    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/1/1c/Alice_through_the_looking_glass.jpg\"\n",
    "     alt=\"Alice through the looking glass\"\n",
    "     style=\"float: left; margin-right: 10px; height: 300px\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Object-oriented programming (OOP)** is a way of writing code using \"objects\". Computer programs that are not object-oriented are a list of instructions for the computer, which is called procedural programming. In OOP computer programs use objects that talk to one another to change the data in those objects and to work the way the user wants. OOP allows code reusability, in different parts of the program or by different developers.\n",
    "\n",
    "Pyhton, like most programming languages, is a mix of different ways of writing computer programs. For example, Python allows both object-oriented programming and procedural programming."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Features\n",
    "\n",
    "In object-oriented programming everything is an object. And there are different types of objects:\n",
    " - Variables, known as **attributes** in OOP, can hold different types of information. For example, an attrubute like *age* for a person could be of integer data type and *names* could be a list of strings.\n",
    " - Procedures, known as **methods** in OOP, are lists of instructions telling the computer to take input, do some calculations or chage data and return an output. For example a person can say their name. In procedural programming they are called functions.\n",
    " - **Classes** are collections of different attributes and methods.\n",
    " \n",
    " **Objects** is a term used to refer to instances of classes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example\n",
    "\n",
    "Let's take the example with person. We can create a **Human** class with three attributes: *age*, *names*, and *friend*. And two methods, to *tell the age* and *say the names*. The \\_\\_init\\_\\_ method is special method classes have called Constructor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Human(object):\n",
    "    def __init__(self, names, age, friend = None):\n",
    "        self.names = names\n",
    "        self.age = age\n",
    "        self.friend = friend\n",
    "    def say_name(self):\n",
    "        print(\"My name is \"+' '.join(self.names)) #concatenate names\n",
    "    def how_old_am_i(self):\n",
    "        print(f\"I am {self.age} years old\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#create a new Human object with 2 names and age 10\n",
    "tarrant = Human(['Tarrant', 'Hightopp'], 20)\n",
    "#create a new Human who is 10 has three names and is friends whith tarrant\n",
    "alice = Human(['Alice', 'Pleasance', 'Liddell'], 10, friend=tarrant)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Let's try the methods\n",
    "tarrant.say_name()\n",
    "tarrant.how_old_am_i()\n",
    "alice.say_name()\n",
    "alice.how_old_am_i()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#let's find out the name of Alice's friend\n",
    "#the friend is in this case an object instance of class Human\n",
    "alice.friend.say_name()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(alice.friend)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Check your understanding\n",
    "\n",
    "Create a *Animal* class with the following attributes: color, name, type, favourite snack and owner.\n",
    "Add the attributes to call the cat and find out the favourite snack.\n",
    "\n",
    "Create a new **Animal** object called *Chessur*, of color grey, who loves salmon and is owned by alice. Can you guess what type of animal Chessur is? \n",
    "How old is alice?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code here\n",
    "#class .. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classes we use every day\n",
    "\n",
    "Did you know that **integers** and **strings** are classes too? They have then a bunch of attributes and methods associated with them. You can access the attributes and methods using the *dir* function in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = 'alice'\n",
    "print(type(name))\n",
    "dir(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see there are some method that begin and end with double underscores. These are called **special methods** and they aren't usually called by those names. Instead, they're called by some internal Pyuthon functions, for example **\\_\\_len\\_\\_** method is called by the **len** function.\n",
    "\n",
    "To see what a specific method does you can use teh **help** function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(name.upper)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "What does the **title** method do?\n",
    "\n",
    "Call it on the name object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Object comparison\n",
    "\n",
    "When comparing objects there are two operators: **==** and **is**\n",
    "\n",
    "The **==** operator compares the values of objects (the data they hold), while **is** compares their identites. We often care about values and not identities, so **==** appears more often. However, if you are comparing a viriable to a singleton, then using *is* makes sense. The most often case is checking if a variable is bound to *None*.\n",
    "\n",
    "```\n",
    "tarrant.friend is None # this will return True\n",
    "alice.friend is not None # this will return True\n",
    "```\n",
    "\n",
    "**==** is the syntactic sugar to **\\_\\_eq\\_\\_**\n",
    "\n",
    "When to use **is** and why: if you want to check if something exists, if you want to check that you have indeed distinct objects, so that you do not accidently edit the wrong object. The is operator is faster than ==, so use it when applcable. \n",
    "\n",
    "\n",
    "Fun fact: for Germans this might comparison is supported by the language itself, where you have **gleich** and **dasselbe**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# looking at lists, where copies are shallow by default\n",
    "l1 = [3, [55,44], (7,8,9)]\n",
    "l2 = list(l1) # this creates a copy of list l1\n",
    "print(l2)\n",
    "print(l1 == l2)\n",
    "print(l1 is l2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Check your understanding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# looking at integers creating some new integers\n",
    "a = 5\n",
    "b = 5\n",
    "c = 10\n",
    "\n",
    "print(a == b)\n",
    "print(a == c)\n",
    "print(a is b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This only happens because.. Python caches small integers.. try it out with 1000 .. is 1000 the same as 10**3 ?\n",
    "\n",
    "What about strings? If you have a variable `x = 'a'` is 'aa' equal or the same as x*2 ?\n",
    "\n",
    "What happens if you assign l1 to l3 with `l3 = l1`, are they distinct lists or the same? How would you check that? What is the value of l1 if you .. run `l3.append('a')`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# code\n",
    "x = 'a'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inheritance and Code Reuse\n",
    "\n",
    "Just like people have parents, grandparents and so on.. objects have an ancestry. The principle of inheritance lets programmers build relationships between concepts and group them together. It allows us to reduce code duplication by generalizing our code.\n",
    "\n",
    "For our *Human* example we could have the *ImaginaryHuman* class.. as we can all agree that some of the poeple in Alice in Wonderland were imaginary.. One can add more properties and new methods or just use **pass** if no changes are needed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ImaginaryHuman(Human):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "red = ImaginaryHuman([\"The Red Queen\"], 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "red.say_name()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Check your understanding\n",
    "\n",
    "Create an imaginary pet class and make a new object.. you can use as inspiration [Alice in wonderland fandom](https://aliceinwonderland.fandom.com/wiki/Alice)\n",
    "\n",
    "Is the new object of the same type as object you made for Chessur? How can you check that?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Summary\n",
    "\n",
    "Congratulations! Hope you had fun with Alice and classes and OOP.\n",
    "\n",
    "Here is what you should be familiar by now with:\n",
    "* how to create a class, with attributes and methods\n",
    "* how to create an instance of a class\n",
    "* how to inherit from a class\n",
    "* when to use is vs =="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}