advanced/01.object-oriented-coding.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 1. Introduction to object-oriented coding with Python\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This Notebook introduces a few things about objects and classes in Python. In case you want to learn more, then please refer to:\n",
    "https://docs.python.org/3/tutorial/classes.html#a-word-about-names-and-objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1 Classes and objects\n",
    "\n",
    "### 1.1.1 Objects\n",
    "The world around us is full of objects: tables, chairs, people, glasses, computers, buildings, wall, etc. When doing **object-oriented programming**, one aims to encode the attributes, properties and functions of those objects, such that the result contains all needed information of these objects. In this object-oriented code, the objects are central to the code, and have all information needed for all encoded objects.\n",
    "\n",
    "### 1.1.2 Classes\n",
    "Classes are very tightly related to the objects introduced above. A synonym for the word `class` is `type`. Each object has a certain expected type or class. For example, the `class` `table` may define that each table has a `name attribute` and has four `properties` relating it to four `legs`. The class is thus a general description or a blueprint of a particular set of objects.\n",
    "\n",
    "### 1.1.3 Example\n",
    "A good understanding of objects and classes is **crucial** for a good understanding of object-oriented coding. The below example illustrates the use of objects and classes for a few building objects.\n",
    "\n",
    "A class is defined as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Building:\n",
    "\n",
    "    # attributes\n",
    "    name = \"Vertigo\"\n",
    "    height = 100\n",
    "    numberOfStoreys = 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once a class is defined (e.g. the `Building` class above), multiple objects of that class can be created. These objects are sometimes also called instances of this class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vertigo is 9 storeys high\n",
      "Atlas is 11 storeys high\n"
     ]
    }
   ],
   "source": [
    "# create vertigo object\n",
    "vertigo = Building()\n",
    "vertigo.name = \"Vertigo\"\n",
    "vertigo.height = 100\n",
    "vertigo.numberOfStoreys = 9\n",
    "\n",
    "# create atlas object\n",
    "atlas = Building()\n",
    "atlas.name = \"Atlas\"\n",
    "atlas.height = 90\n",
    "atlas.numberOfStoreys = 11\n",
    "\n",
    "# access attributes\n",
    "print(f\"{vertigo.name} is {vertigo.numberOfStoreys} storeys high\")\n",
    "print(f\"{atlas.name} is {atlas.numberOfStoreys} storeys high\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2 Functions in class definitions\n",
    "In the above example, the `Building` class definition only contains 3 attribute definitions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Building:\n",
    "\n",
    "    # attributes\n",
    "    name = \"Vertigo\"\n",
    "    height = 100\n",
    "    numberOfStoreys = 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apart from these attributes, classes typically also define the behavior of objects in the mentioned class. This is done by adding `functions` to the class definition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Building:\n",
    "\n",
    "    # attributes\n",
    "    name = \"Vertigo\"\n",
    "    height = 100\n",
    "    numberOfStoreys = 6\n",
    "\n",
    "    # functions\n",
    "    def coolName(self):\n",
    "        return (\"This building has a cool name : \" + self.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So now we can execute some of the functions that belong to this building."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create atlas object\n",
    "atlas = Building()\n",
    "atlas.name = \"Atlas\"\n",
    "atlas.height = 90\n",
    "atlas.numberOfStoreys = 11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This building has a cool name : Atlas'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "atlas.coolName()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.3 What is a constructor?\n",
    "Constructors are used for instantiating an object. They are present in all object-oriented programming languages and they allow to *create instances of the particular class they belong to*. Even if they are not explicitly written inside a class definition, they are implicitly added when compiling the code. They are one of the most basic parts of a class, next to attributes and functions.\n",
    "\n",
    "A constructor in Python can be recognized as something that looks like an `__init__()` method. The task of a constructor is to initialize an instance of a class and assign initial (potentially empty) values to the data members of the class. In Python the __init__() method is always called when an object is created.\n",
    "\n",
    "So let's add a constructor to our earlier example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Building:\n",
    "\n",
    "    # attributes\n",
    "    name = \"Vertigo\"\n",
    "    height = 100\n",
    "    numberOfStoreys = 6\n",
    "\n",
    "    # constructor\n",
    "    def __init__(self):\n",
    "        name = \"Vertigo\"\n",
    "        height = 100\n",
    "        numberOfStoreys = 6\n",
    "\n",
    "    # functions\n",
    "    def coolName(self):\n",
    "        return (\"This building has a cool name : \" + self.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's create a new building object using this constructor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create metaform object\n",
    "metaforum = Building()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When using the default constructor, like we did above, the default values are assigned to the object that we created.\n",
    "\n",
    "*Task:* Guess which name, height and numberOfStoreys the above `metaforum` object has?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vertigo\n",
      "100\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "print(metaforum.name)\n",
    "print(metaforum.height)\n",
    "print(metaforum.numberOfStoreys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is possible to update the attributes of this object manually."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Metaforum\n",
      "60\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "metaforum.name = \"Metaforum\"\n",
    "metaforum.height = 60\n",
    "metaforum.numberOfStoreys = 5\n",
    "\n",
    "print(metaforum.name)\n",
    "print(metaforum.height)\n",
    "print(metaforum.numberOfStoreys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, it would be better if our default values were empty, and we could use a different constructor that enables using custom input values. Unfortunately, it is not possible to include more than 1 constructor in Python by default. \n",
    "\n",
    "So let's redefine our class. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Building:\n",
    "\n",
    "    # constructor\n",
    "    def __init__(self, name, height, numberOfStoreys):\n",
    "        self.name = name\n",
    "        self.height = height\n",
    "        self.numberOfStoreys = numberOfStoreys\n",
    "\n",
    "    # functions\n",
    "    def coolName(self):\n",
    "        return (\"This building has a cool name : \" + self.name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Metaforum 1:\n",
      "Metaforum\n",
      "60\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "metaforum1 = Building(\"Metaforum\", 60, 5)\n",
    "print(\"Metaforum 1:\")\n",
    "print(metaforum1.name)\n",
    "print(metaforum1.height)\n",
    "print(metaforum1.numberOfStoreys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.4 Summary\n",
    "This is the basis of using objects and classes in Python. If you keep expanding the above approach, it is possible to create large **class models** and **object models** that represent important parts of the world around you, including attributes and behavior.\n",
    "\n",
    "The resulting object model can also be referred to as an information model. They are the basis of object-oriented code, and this functionality can be recognized in the object model that is used for web development (e.g. the model in `Django`), or in the IFC model used by `IfcOpenShell`."
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.9.1"
  },
  "toc-autonumbering": true,
  "toc-showcode": false,
  "vscode": {
   "interpreter": {
    "hash": "f2dd3983abb08711ebf993e9d2c0a41f3cbbd887271685058242b02efa6cdf3e"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}