tutorials/data_model.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "eeb899ef-4b82-4c5c-b41b-33000c8766e4",
   "metadata": {},
   "source": [
    "# Data Model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f65fd1a-32e2-4b4a-8758-5a86f172d1e9",
   "metadata": {},
   "source": [
    "Everything that can be stored as a variable in python is an object. Objects come in many different types, which can be differentiated by the data stored in the object and the methods available to the object."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86763cd2-fb2b-4ec5-a1fc-6a78f71713b6",
   "metadata": {},
   "source": [
    "## Attributes and methods"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45edc4bc-6846-4334-a7f8-709dbba2082f",
   "metadata": {},
   "source": [
    "All objects in python have attributes that can be accessed by using the <i>obj.attr</i> syntax. You can also use the _getattr_ function to access an attribute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "12ec1dab-7c23-450c-843f-3305df40d6e9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "one = 1\n",
    "print(one.real) # .real refers to the real component of 1 which is 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "caba25dc-e0c8-412c-935a-a8be827351ad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "print(getattr(one, 'imag')) # .imag refers to the imaginary component of 1 which is 0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb7e7abd-db6c-4df1-ad9c-36c18d615660",
   "metadata": {},
   "source": [
    "Methods are attributes that are functions. There are some things that differentiate normal functions from methods, but we can get into that later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6897928d-b540-4285-9720-9ad223c5523a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "tenbitnumber = 512\n",
    "print(tenbitnumber.bit_length()) # .bit_length calculates how many digits the integer has in binary"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a5f5a08-efdb-4882-a1f0-277d5e26f31e",
   "metadata": {},
   "source": [
    "The _dir_ function returns a _list_ of attributes and methods for an object"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "389e6654-83e6-4187-8a69-c51da3ed8a12",
   "metadata": {},
   "source": [
    "## Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7cdf4059-4cb5-4014-a5f6-4fb383af686d",
   "metadata": {},
   "source": [
    "Functions are also objects, characterized by a <i>\\_\\_call\\_\\_</i> method. The <i>\\_\\_call\\_\\_</i> method allows you to use the <i>func(arg)</i> syntax. Yes, because <i>func.\\_\\_call\\_\\_</i> is a method and therefore also a function, there is also <i>func.\\_\\_call\\_\\_.\\_\\_call\\_\\_</i>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "765a4596-68c6-4c97-aee7-ede2fd590799",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "def identity(x): # Identity function, return the argument\n",
    "    return x\n",
    "\n",
    "print(identity(1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d38579a8-d46b-445b-86d4-da49c90e6389",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(identity.__call__(1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f96a82d-3832-4b86-a0cb-a8535170e18d",
   "metadata": {},
   "source": [
    "## Classes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6224e50a-5cd0-4105-8b87-55d2f614b37a",
   "metadata": {},
   "source": [
    "You can create classes with the _class_ keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "8648add6-8d40-4fdd-8edb-e5f64e7ac486",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyClass: # Create new class MyClass\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8cfa47e2-6642-4b03-a5ab-b6ddefdd86d7",
   "metadata": {},
   "source": [
    "Create instances of new class by using the <i>cls(args)</i> syntax."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "0e402e1d-ea9c-4415-8fde-892e91aeb834",
   "metadata": {},
   "outputs": [],
   "source": [
    "myclass_instance = MyClass() # Create an instance of the MyClass class"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "724d6434-7ac9-442b-9e6f-283c0ae97b36",
   "metadata": {},
   "source": [
    "The <i>\\_\\_init\\_\\_</i> method is always run immediately after instantiation. Let's make a new class with an <i>\\_\\_init\\_\\_</i> method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "c20dc14c-771c-4cf4-b0d4-26d230377a82",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyClass2:\n",
    "    def __init__(self, attr1, attr2): # Initialization function\n",
    "        # All standard methods in a class definition require at least one argument\n",
    "        # This first argument (usually called self) refers to the instance of the class\n",
    "        self.attr1 = attr1 # Set attributes of the instance\n",
    "        self.attr2 = attr2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c2f4987-0b0a-4321-a7fa-dbac001f3a69",
   "metadata": {},
   "source": [
    "When instantiating the class, the arguments for the class are the arguments for the <i>\\_\\_init\\_\\_</i> method minus _self_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "7d42a6bb-020a-45ff-9728-759383e66bd0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "a\n"
     ]
    }
   ],
   "source": [
    "myclass2_instance = MyClass2(1, 'a') # Arguments are same as arguments for __init__ minus self\n",
    "print(myclass2_instance.attr1)\n",
    "print(myclass2_instance.attr2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94970e53-387b-4638-8bfe-d522c90810b0",
   "metadata": {},
   "source": [
    "### Inheritance"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e63b8eec-d4ff-45e7-be3d-29156ecee6a7",
   "metadata": {},
   "source": [
    "The ability to add objects comes from their <i>\\_\\_add\\_\\_</i> method. In fact, <i>x + y</i> is actually equivalent to <i>x.\\_\\_add\\_\\_(y)</i>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "597f0141-ae9b-476e-b260-1c0456f4073e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "print((1).__add__(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6ee5bbe-753f-4afe-b70f-f45474b67618",
   "metadata": {},
   "source": [
    "We can change this behavior by making a new class inheriting from the int type and overwriting the <i>\\_\\_add\\_\\_</i> method. Classes by default inherit from _object_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "187adb29-69e2-432c-9f69-cf1805e01fa9",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyInt(int): # Create a new class inheriting all attributes and methods from the int type\n",
    "    def __add__(self, other): # Defining a method that already exists in the parent class will overwrite the parent method\n",
    "        return self - other # Overwrite the __add__ method so that it subtracts the numbers instead"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "f49ee100-3b12-4fa3-a1dd-6623a8065d13",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "x = MyInt(5)\n",
    "y = MyInt(3)\n",
    "\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae665c24-e9e7-4fcf-b6a7-870b3b15ac82",
   "metadata": {},
   "source": [
    "What will happen when we add them together?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "e4becdcc-4c4a-457d-9444-a85169bb209e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "print(x + y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "004722e1-ee27-4c71-a88a-f39375d39d12",
   "metadata": {},
   "source": [
    "It subtracts them instead"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "345889b3-ac3a-4503-9f2a-e9603760e813",
   "metadata": {},
   "source": [
    "### Dunder methods"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce9ad3ec-a047-4083-87c7-014a4866c1b7",
   "metadata": {},
   "source": [
    "Methods with double underscores before and after such as <i>\\_\\_init\\_\\_</i> and <i>\\_\\_add\\_\\_</i> discussed earlier are called dunder (double underscore) methods. More examples include:\n",
    "\n",
    "<i>\\_\\_init\\_\\_(self, *args)</i>: Runs immediately after instantiation\n",
    "\n",
    "<i>\\_\\_new\\_\\_(self, *args)</i>: Defines instantiation\n",
    "\n",
    "<i>\\_\\_add\\_\\_(self, other)</i>: Defines behavior of the _+_ operator\n",
    "\n",
    "<i>\\_\\_str\\_\\_(self)</i>: Defines behavior of the _str_ function\n",
    "\n",
    "<i>\\_\\_repr\\_\\_(self)</i>: Defines how the instance is represented by the _print_ function (defaults to <i>\\_\\_str\\_\\_</i> if not set)\n",
    "\n",
    "<i>\\_\\_getitem\\_\\_(self, other)</i>: Defines behavior of the <i>self[other]</i> syntax\n",
    "\n",
    "<i>\\_\\_setitem\\_\\_(self, other, item)</i>: Defines behavior of the <i>self[other] = item</i> syntax\n",
    "\n",
    "<i>\\_\\_call\\_\\_(self, *args)</i>: Defines behavior of the <i>self(*args)</i> syntax\n",
    "\n",
    "<i>\\_\\_len\\_\\_(self)</i>: Defines behavior of the _len_ function\n",
    "\n",
    "<i>\\_\\_iadd\\_\\_(self, other)</i>: Defines behavior of the _+=_ operator\n",
    "\n",
    "<i>\\_\\_contains\\_\\_(self, other)</i>: Defines behavior of the <i>other in self</i> syntax\n",
    "\n",
    "<i>\\_\\_gt\\_\\_(self, other)</i>: Defines behavior of the _>_ operator"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70e1130d-f222-4650-bd8c-33a9ac00113a",
   "metadata": {},
   "source": [
    "### Class methods"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cde956fb-38e9-4bf4-b718-246ba31cff3b",
   "metadata": {},
   "source": [
    "Class methods are defined using the _@classmethod_ decorator. For a class method, the first argument is the class rather than the instance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "a5781c26-b4f1-4271-afc1-808e64b6ce37",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyClass3:\n",
    "    @classmethod # Define a class method\n",
    "    def class_method(cls):\n",
    "        return 5\n",
    "    \n",
    "    def instance_method(self): # Define an identical instance method\n",
    "        return 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89ba0399-ffd4-40fa-ad5b-203bfe8d6ee1",
   "metadata": {},
   "source": [
    "The class method can be run from an instance or from the class itself"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "7c87c4aa-eae2-47f8-ad3d-2108173be34f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "myclass3_instance = MyClass3()\n",
    "print(myclass3_instance.class_method())\n",
    "print(MyClass3.class_method())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d84b1c8a-c9f4-4889-9285-d6c16577e88d",
   "metadata": {},
   "source": [
    "Running an instance method from the class itself requires an instance as the first argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "8fb41fd7-8418-4bd6-9c86-75006185521a",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "instance_method() missing 1 required positional argument: 'self'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[0;32mIn [16]\u001b[0m, in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mMyClass3\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minstance_method\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m)\n",
      "\u001b[0;31mTypeError\u001b[0m: instance_method() missing 1 required positional argument: 'self'"
     ]
    }
   ],
   "source": [
    "print(MyClass3.instance_method())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "3e333915-5a81-4eb4-9ce3-b59e1a1c07e1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "print(MyClass3.instance_method(myclass3_instance))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a6d0f7f-2118-47cc-b4c6-436244c8f661",
   "metadata": {},
   "source": [
    "### Static methods"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dcf5dda1-969d-4219-93be-f335228948b6",
   "metadata": {},
   "source": [
    "Static methods are defined using the _@staticmethod_ decorator. There is no first argument requirement for a static method, they are like normal functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "86b94ec2-6ce0-4313-9593-7d3c30b09620",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyClass4(MyClass3): # Inherit from MyClass3\n",
    "    @staticmethod # Define a static method\n",
    "    def static_method():\n",
    "        return 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "d66e1871-3e65-4417-8931-65645152dc6f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "myclass4_instance = MyClass4()\n",
    "print(myclass4_instance.static_method())\n",
    "print(MyClass4.static_method())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a1ddf89f-f3f4-4dc8-bc82-efe3b24d3b89",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}