Lecture6-classes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "578db769-0c2c-4902-b8de-60a8e8c06c8b",
   "metadata": {},
   "source": [
    "### **Classes** "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16bdde07-ce54-4dde-afe3-5e6e982404fe",
   "metadata": {},
   "source": [
    "Classes in Python are used to define custom data structures and bundle together data and functions that operate on it. Classes provide a way to structure code and encapsulate data, making it easier to manage, maintain and reuse your code. \n",
    "\n",
    "\n",
    "Let's look at the basic syntax:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d399a2da-3c69-4c88-9c57-e48b2e8526ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyFirstClass: #syntax to define a class\n",
    "    \"\"\" My First Class documentation \"\"\"\n",
    "    some_variable = 757 #member variable\n",
    "    \n",
    "    def greet(self): #member function\n",
    "         print(\"Hello, World, I'm a useless class!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b839a8ad-624a-471c-a85c-dedbce85ee93",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.MyFirstClass'>\n",
      "757\n",
      "Hello, World, I'm a useless class!\n",
      "234\n",
      "can change to string\n"
     ]
    }
   ],
   "source": [
    "myvar = MyFirstClass() #create a class instance\n",
    "print(type(myvar))\n",
    "print(myvar.some_variable) #print the data\n",
    "myvar.greet() #call a member function\n",
    "myvar.some_variable = 234 #change a member variable\n",
    "print(myvar.some_variable)\n",
    "myvar.some_variable = \"can change to string\" #change a member variable to a different type\n",
    "print(myvar.some_variable)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ae86109-7f6a-4000-a538-69fd8ca55dbc",
   "metadata": {},
   "source": [
    "The `__init__` method in is a special method in Python classes, also known as a constructor. It is called automatically when a new instance of the class is created, and it is used to initialize the instance variables of the class.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "d5d56950-98a9-42b6-a7e5-e90e04eb2bc4",
   "metadata": {},
   "outputs": [],
   "source": [
    " class MySecondClass:\n",
    "    \"\"\" My Second Class documentation \"\"\" \n",
    "   # number=0\n",
    "    def __init__(self, number):\n",
    "        self.number = number"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42821d6d-83cc-4cd5-a9d3-48452c34ae07",
   "metadata": {},
   "source": [
    "Note that `self` is obligatory as a first argument to all class functions. On the bright side, you can reuse names of member variables for initialization parameters. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "850e03e1-5d80-4ad6-be5a-3a3feeeadce9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "myvar2=MySecondClass(5)\n",
    "myvar3=MySecondClass(7)\n",
    "print(myvar2.number)\n",
    "print(myvar3.number)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1d4bfd9-0e55-49a3-bb9a-b2002425808e",
   "metadata": {},
   "source": [
    "Changing the values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "0e325f09-84d6-4bbb-8f60-80367b701812",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "99\n",
      "111\n"
     ]
    }
   ],
   "source": [
    "myvar2.number=99\n",
    "myvar3.number=111\n",
    "print(myvar2.number)\n",
    "print(myvar3.number)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7d408a9-9aa9-4e82-bb1e-7f57745dda76",
   "metadata": {},
   "source": [
    "You can add variables to the class or class instance after the definition, but it's bad practice as it makes the code hard to understand."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "b915388d-4d1a-4c48-8110-ac37638b39d4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "myvar2.new_var=8 #this was not defined in a class, don't do that\n",
    "myvar3.new_var=7\n",
    "print(myvar2.new_var)\n",
    "print(myvar3.new_var)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9249ae2-6504-4e3c-a0ee-b54917d2f7d8",
   "metadata": {},
   "source": [
    "This will only add the variable to the instance of the class, not the class itself. You can add the variable by calling the name of the class though (again, don't do that)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "3ea67924-7fd8-4a11-8f98-abc604b65a4b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n"
     ]
    }
   ],
   "source": [
    "MySecondClass.new_var=11; #don't do this\n",
    "myvar5=MySecondClass(0)\n",
    "print(myvar5.new_var)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57eec161-55ac-424e-a704-722320b99c7e",
   "metadata": {},
   "source": [
    "Not that the assignent is just another label, not a copy. You would need to implement the `copy` fucntion to actually create a copy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "7be73741-b848-4db2-ae81-e1cd8cd8f0fc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5679\n"
     ]
    }
   ],
   "source": [
    "myvar6=myvar3 #just an extra label, not a copy\n",
    "myvar3.number=5679\n",
    "print(myvar6.number)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75e55114-055d-4024-841b-b015038e5a8b",
   "metadata": {},
   "source": [
    "### **More meaningful example:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "abcdbe74-c576-44c4-9583-fbd5ae029fa0",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Coordinate:\n",
    "    def __init__(self, x=0, y=0):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "    def distance(self, other_coordinate):\n",
    "        x_diff = (self.x - other_coordinate.x)**2\n",
    "        y_diff = (self.y - other_coordinate.y)**2\n",
    "        return (x_diff + y_diff)**0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "d1c969eb-0079-4d53-9f41-e8a6811689ea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7.810249675906654\n"
     ]
    }
   ],
   "source": [
    "point1 = Coordinate()\n",
    "point2 = Coordinate(5, 6)\n",
    "print(point1.distance(point2))  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0175e11b-c4af-40f0-93e9-9d1c20230bdd",
   "metadata": {},
   "source": [
    "#### **How to define a printing operation:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "4216373d-a519-4a3f-8988-8fadd6eced1a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.MySecondClass object at 0x7f41604603a0>\n"
     ]
    }
   ],
   "source": [
    "print(myvar3) #no actual info, need to define a function for this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "78cdd797-cc47-41e6-bdfb-e7c2ac4ff641",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyThirdClass:\n",
    "    def __init__(self,a,b):\n",
    "        self.a=a\n",
    "        self.b=b\n",
    "        \n",
    "    def print(self): #non pythonic way, avoid it if possible\n",
    "        print(self.a,self.b)\n",
    "        \n",
    "    def __str__(self):\n",
    "        return \"{0},{1}\".format(self.a, self.b) #\"converts\" class to a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "4b5690b0-ab54-485f-b79e-f63318920adb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22,33\n",
      "99 0\n"
     ]
    }
   ],
   "source": [
    "print(MyThirdClass(22,33))\n",
    "MyThirdClass(99,0).print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d86e447-3826-4d44-bc0d-7ffa5867a520",
   "metadata": {},
   "source": [
    "The method name `__str__` starts with double underscores because it is a special method in Python called a \"magic method\" (that's another type of \"magic\", it has nothing to do with Jupyter this time) or \"dunder\" (short for \"double underscore\"). \n",
    "\n",
    "The `__str__` magic method is used to define the string representation of an object, which is what is displayed when you call print on the object or convert it to a string using `str()`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1f5e84c-b29b-4cb0-8c41-82ccc1195cca",
   "metadata": {},
   "source": [
    "#### **Defining operators:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "48f1ab8b-9cb9-4ade-b9fe-0dbb11494a82",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'MyThirdClass' and 'MyThirdClass'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[24], line 3\u001b[0m\n\u001b[1;32m      1\u001b[0m var1\u001b[38;5;241m=\u001b[39mMyThirdClass(\u001b[38;5;241m11\u001b[39m,\u001b[38;5;241m22\u001b[39m)\n\u001b[1;32m      2\u001b[0m var2\u001b[38;5;241m=\u001b[39mMyThirdClass(\u001b[38;5;241m22\u001b[39m,\u001b[38;5;241m33\u001b[39m)\n\u001b[0;32m----> 3\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mvar1\u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43mvar2\u001b[49m)\n",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'MyThirdClass' and 'MyThirdClass'"
     ]
    }
   ],
   "source": [
    "var1=MyThirdClass(11,22)\n",
    "var2=MyThirdClass(22,33)\n",
    "print(var1+var2) #error"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ec00ebd-293b-4a82-83fc-e48c8df95af5",
   "metadata": {},
   "source": [
    "You need to use more \"magic\" methods for that:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "9f41cd44-5d05-4abe-b991-046be47b3296",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyThirdClass:\n",
    "    def __init__(self,a,b):\n",
    "        self.a=a\n",
    "        self.b=b\n",
    "        \n",
    "    def __add__(self,other):   \n",
    "        a=self.a+other.a\n",
    "        b=self.b+other.b\n",
    "        return MyThirdClass(a,b)\n",
    "        \n",
    "    def __str__(self):\n",
    "        return \"{0},{1}\".format(self.a, self.b) #\"converts\" class to a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "20e762dd-500e-47a4-aa8d-5cb9f5101c6a",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyforthClass(MyThirdClass):\n",
    "    def __init__(self,a,b):\n",
    "        super().__init__(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "7be32ede-e801-4459-ae10-45c636b2114c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "33,44\n"
     ]
    }
   ],
   "source": [
    "h=MyforthClass(33,44)\n",
    "print(h)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "98eb5b20-deba-407c-8727-645cedbf6176",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "33,55\n"
     ]
    }
   ],
   "source": [
    "#note that you have to redefine the variables, or they are not updated after we updated the class\n",
    "var1=MyThirdClass(11,22)\n",
    "var2=MyThirdClass(22,33)\n",
    "print(var1+var2) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b664f70e-e625-44d9-9c7d-78d558849a86",
   "metadata": {},
   "source": [
    "#### **Modules**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a56e8486-14e2-417e-9ab2-b878440c2d44",
   "metadata": {},
   "source": [
    "If your program becomes too long or if you want to reuse the functions/classes you've writen, you might want to create own modules. You just need to create a file with those functions/classes, then `import` it the way you do with numpy."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b19871e-a57c-4485-ba7f-72054aa50472",
   "metadata": {},
   "source": [
    "The `file` cell magic command lets you create a text file with the contents of the cell (of course you can just create that file in any text editor):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "59070244-ba5c-4f76-801f-788fe3c1125f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting mymodule.py\n"
     ]
    }
   ],
   "source": [
    "%%file \"mymodule.py\"\n",
    "\n",
    "def sin(a):\n",
    "    return 77"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "db846aac-1077-4a8c-8e5e-76f25a12f198",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "44fdb8fe-3b63-4ccf-a2a4-a684d468e9f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import mymodule as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "67e12779-79c7-4f62-b141-4fed44e76fd1",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "77"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sin(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3751cbaf-43d6-4ec7-b93e-f5b9bbdd9672",
   "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.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}