6. It is all about class.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "596b789b",
   "metadata": {},
   "source": [
    "# 6.1 Define Class and Instantiate\n",
    "* Property (or in other names: variables, attributes)\n",
    " * Class Property\n",
    " * Instance Property\n",
    "* Method\n",
    " * Instance Method\n",
    " * Static Method\n",
    " * Class Method\n",
    " \n",
    "*refer to https://realpython.com/instance-class-and-static-methods-demystified/*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "712be8d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyClass(object):\n",
    "    \"\"\"\n",
    "    This is an example of a class\n",
    "    MyClass is a self-defined object\n",
    "    MyClass is similar to other objective like int, float, str, list, dict, all of which belong to python object\"\"\"\n",
    "    class_property1 = list()\n",
    "    \n",
    "    def __init__(self, instance_property1, instance_property2):\n",
    "        \"\"\"\n",
    "        instance initialization method __init__\n",
    "        self represents an instance of MyClass\n",
    "        \"\"\"\n",
    "        self.instance_property1 = instance_property1\n",
    "        self.instance_property2 = instance_property2\n",
    "        \n",
    "    def instance_method1(self):\n",
    "        \"\"\"\n",
    "        an instance method\n",
    "        instance_method1(self) means input an instance of MyClass, \"self\" for instance_method1\n",
    "        to call this, use instance_name.instance_method1()\n",
    "        \"\"\"\n",
    "        print(f\"This is Class {self.__class__.__name__!r}: Instance Method\")\n",
    "        print('instance method called', self)\n",
    "    \n",
    "    @staticmethod\n",
    "    def static_method1():\n",
    "        # a static method\n",
    "        print(f\"This is Class 'MyClass': Static Method\")\n",
    "        print('static method called')\n",
    "    \n",
    "    @classmethod\n",
    "    def class_method1(cls):\n",
    "        # a class method\n",
    "        print(f\"This is Class {cls.__name__!r}: Class Method\")\n",
    "        print('class method called', cls)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f76f2a4",
   "metadata": {},
   "source": [
    "### **instance method, static method and class method**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "34e838ff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.MyClass object at 0x0000025E5F05D910>\n",
      "True\n",
      "False\n",
      "True\n",
      "<class '__main__.MyClass'>\n",
      "True\n",
      "True\n",
      "\n",
      "\n",
      "This is Class 'MyClass': Instance Method\n",
      "instance method called <__main__.MyClass object at 0x0000025E5F05D910>\n",
      "This is Class 'MyClass': Instance Method\n",
      "instance method called <__main__.MyClass object at 0x0000025E5F05D910>\n",
      "This is Class 'MyClass': Instance Method\n",
      "instance method called <__main__.MyClass object at 0x0000025E5F060040>\n",
      "\n",
      "\n",
      "This is Class 'MyClass': Static Method\n",
      "static method called\n",
      "This is Class 'MyClass': Static Method\n",
      "static method called\n",
      "This is Class 'MyClass': Static Method\n",
      "static method called\n",
      "\n",
      "\n",
      "This is Class 'MyClass': Class Method\n",
      "class method called <class '__main__.MyClass'>\n",
      "This is Class 'MyClass': Class Method\n",
      "class method called <class '__main__.MyClass'>\n",
      "This is Class 'MyClass': Class Method\n",
      "class method called <class '__main__.MyClass'>\n"
     ]
    }
   ],
   "source": [
    "# Instantiate class\n",
    "instance1 = MyClass(1, 2)\n",
    "print(instance1)\n",
    "# isinstance and issubclass\n",
    "print(isinstance(instance1, MyClass))\n",
    "print(isinstance(MyClass, MyClass))\n",
    "print(isinstance(MyClass(1, 2), MyClass))\n",
    "print(type(instance1))\n",
    "print(issubclass(MyClass, MyClass))\n",
    "print(issubclass(MyClass, object))\n",
    "print('\\n')\n",
    "\n",
    "\n",
    "# run instance_method1()\n",
    "instance1.instance_method1()\n",
    "# formula below is the same as the above one, that is, instance1 (or self) is passed to instance_method1\n",
    "MyClass.instance_method1(instance1)\n",
    "# The following operation: firstly create an instance MyClass (1, 2), and then call instance_method1\n",
    "MyClass(1, 2).instance_method1()\n",
    "# why below code will raise an error?\n",
    "# MyClass.instance_method()\n",
    "print('\\n')\n",
    "\n",
    "\n",
    "# run static_method1()\n",
    "\"\"\"Did you see how we called staticmethod() on the object \n",
    "and were able to do so successfully?\n",
    "Behind the scenes Python simply enforces the access restrictions \n",
    "by not passing in the self or the cls argument \n",
    "when a static method gets called using the dot syntax.\"\"\"\n",
    "# for staticmethod，python will force not to pass instance or class\n",
    "instance1.static_method1()\n",
    "MyClass(1, 2).static_method1()\n",
    "MyClass.static_method1()\n",
    "print('\\n')\n",
    "\n",
    "\n",
    "# run class_method1()\n",
    "\"\"\"Did you see how we called classmethod() on the object \n",
    "and were able to do so successfully?\n",
    "Behind the scenes Python simply enforces the access restrictions \n",
    "by passing in the cls argument \n",
    "when a class method gets called using the dot syntax.\"\"\"\n",
    "# For classmethod，python will force to pass class for classmethod\n",
    "instance1.class_method1()\n",
    "MyClass(1, 2).class_method1()\n",
    "MyClass.class_method1()\n",
    "# Below will raise error\n",
    "# MyClass.class_method1(instance1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce3743a8",
   "metadata": {},
   "source": [
    "### **instance property**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "24efa17f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "\n",
      "\n",
      "1\n",
      "1\n",
      "\n",
      "\n",
      "10\n",
      "100\n",
      "\n",
      "\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# instance property\n",
    "\n",
    "## has, get, set, del attributes\n",
    "print(hasattr(instance1, 'instance_property1'))\n",
    "print('\\n')\n",
    "\n",
    "print(instance1.instance_property1)\n",
    "print(getattr(instance1, 'instance_property1'))\n",
    "print('\\n')\n",
    "\n",
    "instance1.instance_property1 = 10\n",
    "print(instance1.instance_property1)\n",
    "setattr(instance1, 'instance_property1', 100)\n",
    "print(instance1.instance_property1)\n",
    "print('\\n')\n",
    "\n",
    "del instance1.instance_property1\n",
    "print(hasattr(instance1, 'instance_property1'))\n",
    "instance1.instance_property1 = 100\n",
    "delattr(instance1, 'instance_property1')\n",
    "print(hasattr(instance1, 'instance_property1'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14a7ce78",
   "metadata": {},
   "source": [
    "### **class property**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c3de05da",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "[]\n",
      "[]\n",
      "\n",
      "\n",
      "[]\n",
      "1\n",
      "[1]\n",
      "[1]\n",
      "\n",
      "\n",
      "[1, 2]\n",
      "[1, 2]\n",
      "\n",
      "\n",
      "[]\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "instance1 = MyClass(1, 2)\n",
    "print(instance1.instance_property2)\n",
    "print(instance1.class_property1)\n",
    "print(MyClass.class_property1)\n",
    "print('\\n')\n",
    "\n",
    "# modify class_property1 via instance will not change class property\n",
    "instance1.class_property1 = 1\n",
    "print(MyClass.class_property1)\n",
    "print(instance1.class_property1)\n",
    "\n",
    "# however, since list space is shared, below codes can happen\n",
    "# this principle is similar to tuple with list elements\n",
    "instance1 = MyClass(1, 2)\n",
    "MyClass.class_property1.append(1)\n",
    "print(MyClass.class_property1)\n",
    "print(instance1.class_property1)\n",
    "print('\\n')\n",
    "\n",
    "instance1.class_property1.append(2)\n",
    "print(MyClass.class_property1)\n",
    "print(instance1.class_property1)\n",
    "print('\\n')\n",
    "\n",
    "MyClass.class_property1 = []\n",
    "print(MyClass.class_property1)\n",
    "print(instance1.class_property1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fdc7b5e",
   "metadata": {},
   "source": [
    "# 6.2 Class Inheritance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7ab51efb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling child constructor\n",
      "Calling child method\n",
      "Parent attribute : 100\n",
      "Calling parent method\n",
      "Parent attribute : 200\n",
      "\n",
      "\n",
      "Calling child constructor\n",
      "The parentMethod has been overrided\n",
      "\n",
      "\n",
      "Calling parent constructor\n",
      "Calling parent method\n",
      "The parentMethod has been overrided\n"
     ]
    }
   ],
   "source": [
    "class Parent(object):\n",
    "    parentAttr = 100\n",
    "    def __init__(self):\n",
    "        print(\"Calling parent constructor\")\n",
    "    def parentMethod(self):\n",
    "        print(\"Calling parent method\")\n",
    "    def setAttr(self, attr):\n",
    "        Parent.parentAttr = attr\n",
    "    def getAttr(self):\n",
    "        print(\"Parent attribute :\", Parent.parentAttr)\n",
    "        \n",
    "class Child(Parent):\n",
    "    def __init__(self):\n",
    "        print(\"Calling child constructor\")\n",
    "    # define child method which belongs solely to Child Class\n",
    "    def childMethod(self):\n",
    "        print('Calling child method')\n",
    "c = Child()\n",
    "c.childMethod()\n",
    "# can also call parent's method\n",
    "c.getAttr()\n",
    "c.parentMethod()     # calls parent's method\n",
    "c.setAttr(200)       # again call parent's method\n",
    "c.getAttr()          # again call parent's method\n",
    "print('\\n')\n",
    "\n",
    "# overriding methods\n",
    "class Child(Parent):\n",
    "    def __init__(self):\n",
    "        print(\"Calling child constructor\")\n",
    "    # define child method which belongs solely to children\n",
    "    def parentMethod(self):\n",
    "        print('The parentMethod has been overrided')\n",
    "c = Child()\n",
    "c.parentMethod()\n",
    "print('\\n')\n",
    "\n",
    "# using super() to run parent's methods\n",
    "class Child(Parent):\n",
    "    def __init__(self):\n",
    "        super(Child, self).__init__() # calling parent's __init__\n",
    "    def parentMethod(self):\n",
    "        super(Child, self).parentMethod() # calling parent's parentMethod\n",
    "        print('The parentMethod has been overrided')\n",
    "c = Child()\n",
    "c.parentMethod()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b3f72c30",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(<class '__main__.Parent1'>, <class '__main__.Parent2'>)\n",
      "Parent1\n",
      "Parent2\n"
     ]
    }
   ],
   "source": [
    "# multiple parents\n",
    "class Parent1(object):\n",
    "    def __init__(self):\n",
    "        self.p1 = \"Parent1\"\n",
    "class Parent2(object):\n",
    "    def __init__(self):\n",
    "        self.p2 = \"Parent2\"\n",
    "class Child(Parent1, Parent2):\n",
    "    def __init__(self):\n",
    "        # The following enables two inheritances\n",
    "        Parent1.__init__(self)\n",
    "        Parent2.__init__(self)\n",
    "#         super(Child, self).__init__() # This inherits from the leftmost parent \"Parent 1\"\n",
    "print(Child.__bases__)\n",
    "Child_instance = Child()\n",
    "print(Child_instance.p1)\n",
    "print(Child_instance.p2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da1dfd8e",
   "metadata": {},
   "source": [
    "# 6.3 Setter and Getter\n",
    "    setter and getter are convenient in many ways, and intrinsically use function decorators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c4e6d900",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "class MyClass(object):\n",
    "    def __init__(self, instance_property1, instance_property2):\n",
    "        assert isinstance(instance_property1, int), 'value should be \"int\"'\n",
    "        self._instance_property1 = instance_property1\n",
    "        assert isinstance(instance_property2, int), 'value should be \"int\"'\n",
    "        self._instance_property2 = instance_property2\n",
    "    @property\n",
    "    def instance_property1(self):\n",
    "        \"\"\"\n",
    "        property name 'instance_property1' cannot be the same as the already-existed property,\n",
    "        so we use _instance_property1\n",
    "        \"\"\"\n",
    "        return self._instance_property1\n",
    "    @instance_property1.setter\n",
    "    def instance_property1(self, num):\n",
    "        assert isinstance(num, int), 'value should be \"int\"'\n",
    "        self._instance_property1 = num\n",
    "    @property\n",
    "    def instance_property2(self):\n",
    "        return self._instance_property2\n",
    "    @instance_property2.setter\n",
    "    def instance_property2(self, num):\n",
    "        assert isinstance(num, int), 'value should be \"int\"'\n",
    "        self._instance_property2 = num\n",
    "MyClass_instance = MyClass(1, 2)\n",
    "MyClass_instance.instance_property1 = 10\n",
    "print(MyClass_instance.instance_property1)\n",
    "# code below would raise error\n",
    "# MyClass_instance.instance_property1 = 1."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5779e109",
   "metadata": {},
   "source": [
    "# 6.4 Built-in Attributes for Class\n",
    "    __class__\n",
    "    __dict__\n",
    "    __doc__\n",
    "    __name__\n",
    "    __module__\n",
    "    __bases__\n",
    " * refer to https://www.tutorialspoint.com/python/python_classes_objects.htm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "06db1d26",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'type'>\n",
      "\n",
      "\n",
      "{'__module__': '__main__', '__init__': <function MyClass.__init__ at 0x0000025E5F03E700>, 'instance_property1': <property object at 0x0000025E5F06D220>, 'instance_property2': <property object at 0x0000025E5F06D270>, '__dict__': <attribute '__dict__' of 'MyClass' objects>, '__weakref__': <attribute '__weakref__' of 'MyClass' objects>, '__doc__': None}\n",
      "\n",
      "\n",
      "MyClass\n",
      "\n",
      "\n",
      "__main__\n",
      "\n",
      "\n",
      "numpy\n",
      "numpy\n",
      "(<class 'numpy.ndarray'>,)\n",
      "(<class '__main__.Parent1'>, <class '__main__.Parent2'>)\n",
      "\n",
      "\n",
      "\n",
      "    matrix(data, dtype=None, copy=True)\n",
      "\n",
      "    .. note:: It is no longer recommended to use this class, even for linear\n",
      "              algebra. Instead use regular arrays. The class may be removed\n",
      "              in the future.\n",
      "\n",
      "    Returns a matrix from an array-like object, or from a string of data.\n",
      "    A matrix is a specialized 2-D array that retains its 2-D nature\n",
      "    through operations.  It has certain special operators, such as ``*``\n",
      "    (matrix multiplication) and ``**`` (matrix power).\n",
      "\n",
      "    Parameters\n",
      "    ----------\n",
      "    data : array_like or string\n",
      "       If `data` is a string, it is interpreted as a matrix with commas\n",
      "       or spaces separating columns, and semicolons separating rows.\n",
      "    dtype : data-type\n",
      "       Data-type of the output matrix.\n",
      "    copy : bool\n",
      "       If `data` is already an `ndarray`, then this flag determines\n",
      "       whether the data is copied (the default), or whether a view is\n",
      "       constructed.\n",
      "\n",
      "    See Also\n",
      "    --------\n",
      "    array\n",
      "\n",
      "    Examples\n",
      "    --------\n",
      "    >>> a = np.matrix('1 2; 3 4')\n",
      "    >>> a\n",
      "    matrix([[1, 2],\n",
      "            [3, 4]])\n",
      "\n",
      "    >>> np.matrix([[1, 2], [3, 4]])\n",
      "    matrix([[1, 2],\n",
      "            [3, 4]])\n",
      "\n",
      "    \n"
     ]
    }
   ],
   "source": [
    "print(MyClass.__class__)\n",
    "print('\\n')\n",
    "\n",
    "print(MyClass.__dict__)\n",
    "print('\\n')\n",
    "\n",
    "# Module name in which the class is defined. \n",
    "print(MyClass.__name__)\n",
    "print('\\n')\n",
    "\n",
    "# This attribute the module in which the class is defined\n",
    "print(MyClass.__module__)\n",
    "print('\\n')\n",
    "\n",
    "\n",
    "import numpy\n",
    "print(numpy.array.__module__)\n",
    "print(numpy.matrix.__module__)\n",
    "print(numpy.matrix.__bases__)\n",
    "print(Child.__bases__)\n",
    "print('\\n')\n",
    "\n",
    "# __doc__ stores the documentation of class, if undefined will be none\n",
    "print(numpy.matrix.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd3c7a4f",
   "metadata": {},
   "source": [
    "# 6.5 Built-in Methods in Class to Override\n",
    "    __init__(self, ...)\n",
    "    __repr__(self, ...)\n",
    "    __str__(self, ...)\n",
    "    __iter__(self, ...)\n",
    "    __call__(self, ...)\n",
    " * refer to https://www.tutorialspoint.com/python/python_classes_objects.htm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "2ec0b0ba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Attribute 'a' is 1,\n",
      "Attribute 'v_list' is [2, 3]\n",
      "\n",
      "\n",
      "100\n",
      "\n",
      "\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "class MyClass2(object):\n",
    "    # __init__ method for initialization\n",
    "    def __init__(self, a, b, c):\n",
    "        self.a = a\n",
    "        self.v_list = [b, c]\n",
    "        \n",
    "    # __iter__ method for iterable\n",
    "    def __iter__(self):\n",
    "        return iter(self.v_list)\n",
    "    \n",
    "    # __call__ method can directly run class like function\n",
    "    # __call__ is widely used in machine learning\n",
    "    def __call__(self, x):\n",
    "        return x**2\n",
    "    \n",
    "    # Printable string representation\n",
    "    def __repr__(self):\n",
    "        return f\"Attribute 'a' is {self.a},\\nAttribute 'v_list' is {self.v_list}\"\n",
    "\n",
    "MyClass2_instance = MyClass2(1, 2, 3)\n",
    "\n",
    "# Below is defined by __repr__\n",
    "# Can try to comment-out method __repr__, and then execute again and compare\n",
    "print(MyClass2_instance)\n",
    "print('\\n')\n",
    "\n",
    "# Below is defined by __call__\n",
    "print(MyClass2_instance(10))\n",
    "print('\\n')\n",
    "\n",
    "# Below is defined by __iter__\n",
    "for v in MyClass2_instance:\n",
    "    print(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "81e6ed22",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "\n",
      "\n",
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "# __iter__ defines the class to be iterable\n",
    "# Another example of iterable class, which uses both __iter__ and __reversed__\n",
    "class Node:\n",
    "    def __init__(self, value):\n",
    "        self._value =  value \n",
    "        self._children = list()\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return 'NTU_school({!r})'.format(self._value)\n",
    "    \n",
    "    def add_new(self,node):\n",
    "        self._children.append(node._value)\n",
    "    \n",
    "    def __iter__(self):\n",
    "        return iter(self._children)\n",
    "    \n",
    "    def __reversed__(self):\n",
    "        return sorted(self._children, reverse=True)\n",
    "if __name__ == '__main__':\n",
    "    root = Node(0)\n",
    "    new1 = Node(1)\n",
    "    new2 = Node(2)\n",
    "    root.add_new(new1)\n",
    "    root.add_new(new2)\n",
    "    for item in root:\n",
    "        print(item)\n",
    "    print('\\n')\n",
    "    for item in reversed(root):\n",
    "        print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db93a26a",
   "metadata": {},
   "source": [
    "# 6.6 Underscores in Python\n",
    "* Ignoring values\n",
    "* Getting value of the last expression in interpreter\n",
    "* Separating digits of numbers \n",
    "* naming\n",
    "    * single pre underscore\n",
    "    * single post underscore\n",
    "    * double pre underscores\n",
    "    * double pre and post underscores\n",
    " \n",
    "refer to https://www.tutorialspoint.com/python/python_classes_objects.htm"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4907a88a",
   "metadata": {},
   "source": [
    "### **Ignoring values**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "880641f8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 3\n",
      "\n",
      "\n",
      "1 11\n",
      "\n",
      "\n",
      "Hi Yo fannie!\n",
      "Hi Yo fannie!\n",
      "Hi Yo fannie!\n"
     ]
    }
   ],
   "source": [
    "a, _, b = 1, 2, 3\n",
    "print(a, b)\n",
    "print('\\n')\n",
    "\n",
    "a, *_, b = 1, 5, 7, 9, 3, 11\n",
    "print(a, b)\n",
    "print('\\n')\n",
    "\n",
    "def func(name):\n",
    "    print(f'Hi Yo {name}!')\n",
    "for _ in range(3):\n",
    "    func('fannie')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4dfd9c73",
   "metadata": {},
   "source": [
    "### **Getting value of the last expression**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "4a877823",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 3 2\n",
      "\n",
      "\n",
      "1 11 [5, 7, 9, 3]\n",
      "\n",
      "\n",
      "Python\n",
      "JS\n",
      "PHP\n",
      "Java\n"
     ]
    }
   ],
   "source": [
    "a, _, b = 1, 2, 3\n",
    "print(a, b, _)\n",
    "print('\\n')\n",
    "\n",
    "a, *_, b = 1, 5, 7, 9, 3, 11\n",
    "print(a, b, _)\n",
    "print('\\n')\n",
    "\n",
    "languages = [\"Python\", \"JS\", \"PHP\", \"Java\"]\n",
    "for _ in languages:\n",
    "    print(_)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e36f7159",
   "metadata": {},
   "source": [
    "### **Separating digits of numbers**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "3bcb62c1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000000\n",
      "2\n",
      "52\n",
      "9131\n"
     ]
    }
   ],
   "source": [
    "million = 1_000_000\n",
    "binary = 0b_0010\n",
    "octa = 0o_64\n",
    "hexa = 0x_23_ab\n",
    "\n",
    "print(million)\n",
    "print(binary)\n",
    "print(octa)\n",
    "print(hexa)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df8f7594",
   "metadata": {},
   "source": [
    "### **Naming (Important)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "5731246f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "trying the import\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "# single pre underscore: _name\n",
    "# it claims the variable or function to be private (for internal use)\n",
    "class Test:\n",
    "    def __init__(self):\n",
    "        self.name = \"trying the import\"\n",
    "        self._num = 7\n",
    "obj = Test()\n",
    "print(obj.name)\n",
    "print(obj._num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "1b837bfd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing E:\\Python in 3 days\\test_func.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile \"E:\\Python in 3 days\\test_func.py\"\n",
    "# On your own computer, change the above path to your current path\n",
    "def func():\n",
    "    return \"trying the import\"\n",
    "\n",
    "def _private_func():\n",
    "    return 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "ecc5f080",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "trying the import\n",
      "\n",
      "\n",
      "trying the import\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "from test_func import *\n",
    "# Python doesn't import the names which starts with a single pre underscore.\n",
    "\n",
    "print(func())\n",
    "# print(_private_func()) # raise error\n",
    "print('\\n')\n",
    "\n",
    "# But you can use this method to call private variables or functions\n",
    "import test_func\n",
    "print(test_func.func())\n",
    "print(test_func._private_func()) # raise error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "e53ad80d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# single post underscore: name_\n",
    "\"\"\"\n",
    "    Sometimes if you want to use Python Keywords (such as class, if) as a variable, \n",
    "    function or class names, you can use this convention for that.\n",
    "    \n",
    "    Or if you can use single post underscore to distinguish with python built-in functions (such as print, min, etc.)\n",
    "\"\"\"\n",
    "# Below can work\n",
    "def function(class_):\n",
    "    pass\n",
    "\n",
    "# Below will raise error\n",
    "# def function(class):\n",
    "#     pass\n",
    "\n",
    "# Use the way below\n",
    "def min_(list0):\n",
    "    MIN = list0[0]\n",
    "    for i in list0:\n",
    "        if i < MIN: MIN = i\n",
    "    return MIN\n",
    "\n",
    "# No error will incur, but please avoid such usage\n",
    "# def min(list0):\n",
    "#     MIN = list0[0]\n",
    "#     for i in list0:\n",
    "#         if i < MIN: MIN = i\n",
    "#     return MIN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "53afe22c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['_Sample__c', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_b', 'a']\n",
      "3\n",
      "3\n",
      "\n",
      "\n",
      "overriden\n",
      "overriden\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# double pre underscore: __name\n",
    "\"\"\"\n",
    "    Double Pre Underscores are used for the name mangling in class.\n",
    "\n",
    "    Double Pre Underscores tells the Python interpreter to rewrite \n",
    "    the attribute name of subclasses to avoid naming conflicts.\n",
    "    \n",
    "    It is to avoid the overriding of the variable in subclasses.\n",
    "\"\"\"\n",
    "class Sample():\n",
    "\n",
    "    def __init__(self):\n",
    "        self.a = 1\n",
    "        self._b = 2\n",
    "        self.__c = 3\n",
    "obj1 = Sample()\n",
    "print(dir(obj1))\n",
    "print(obj1._Sample__c) # name after mangling\n",
    "print(getattr(obj1, f\"_{obj1.__class__.__name__}__c\"))\n",
    "# print(obj1.__c) # raise error\n",
    "print('\\n')\n",
    "\n",
    "# it is to avoid overriding in subclasses\n",
    "class SubSample(Sample):\n",
    "    def __init__(self):\n",
    "        super(SubSample, self).__init__()\n",
    "        self.a = \"overriden\"\n",
    "        self._b = \"overriden\"\n",
    "        self.__c = \"overriden\"\n",
    "obj2 = SubSample()\n",
    "print(obj2.a)\n",
    "print(obj2._b)\n",
    "print(obj2._Sample__c) # avoid override"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "ba4fa8bb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\n    In Python, you will find different names which start and end with the double underscore. \\n    They are called as magic methods or dunder methods.\\n    every magic method has its own meaning，such as\\n    __init__(self, ...)\\n    __repr__(self, ...)\\n    __str__(self, ...)\\n    __iter__(self, ...)\\n    __call__(self, ...)\\n'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# double pre and post underscore: __name__\n",
    "\"\"\"\n",
    "    In Python, you will find different names which start and end with the double underscore. \n",
    "    They are called as magic methods or dunder methods.\n",
    "    every magic method has its own meaning，such as\n",
    "    __init__(self, ...)\n",
    "    __repr__(self, ...)\n",
    "    __str__(self, ...)\n",
    "    __iter__(self, ...)\n",
    "    __call__(self, ...)\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd95a03a",
   "metadata": {},
   "source": [
    "# 6.7 Abstract Class Using ABC (Abstract Base Class)\n",
    "    This module provides the metaclass ABCMeta for defining ABCs and a helper class ABC to alternatively define ABCs through inheritance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "8a560456",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "(<class '__main__.C'>,)\n"
     ]
    }
   ],
   "source": [
    "import abc\n",
    "from abc import abstractmethod\n",
    "\n",
    "\"\"\"Using this decorator requires that the class’s metaclass is ABCMeta or is derived from it. \n",
    "A class that has a metaclass derived from ABCMeta cannot be instantiated unless all of its abstract \n",
    "methods and properties are overridden. The abstract methods can be called using any of the normal \n",
    "‘super’ call mechanisms. abstractmethod() may be used to declare abstract methods for properties and descriptors.\"\"\"\n",
    "\n",
    "class C(abc.ABC):\n",
    "    \"\"\"Define the necessary abstract bone structure\"\"\"\n",
    "    @abstractmethod\n",
    "    def my_abstract_method(self):\n",
    "        pass\n",
    "    \n",
    "    @classmethod\n",
    "    @abstractmethod\n",
    "    def my_abstract_classmethod(cls):\n",
    "        pass\n",
    "    \n",
    "    @property\n",
    "    @abstractmethod\n",
    "    def my_abstract_property(self):\n",
    "        pass\n",
    "    \n",
    "    @my_abstract_property.setter\n",
    "    @abstractmethod\n",
    "    def my_abstract_property(self, val):\n",
    "        pass\n",
    "\n",
    "class Child_C(C):\n",
    "    def __init__(self):\n",
    "        pass\n",
    "# Child_C cannot be instantiated, since didnot define all the required abstractmethod\n",
    "# Child_C_instance = Child_C() # raise error\n",
    "\n",
    "class Child_C2(C):\n",
    "    def __init__(self):\n",
    "        super(Child_C2, self).__init__()\n",
    "        \n",
    "    def my_abstract_method(self):\n",
    "        print('Defined my_abstract_method')\n",
    "        \n",
    "    @classmethod\n",
    "    def my_abstract_classmethod(cls):\n",
    "        print('Defined my_abstract_classmethod')\n",
    "    \n",
    "    @staticmethod\n",
    "    def my_abstract_staticmethod():\n",
    "        print('Defined my_abstract_staticmethod')\n",
    "    \n",
    "    @property\n",
    "    def my_abstract_property(self):\n",
    "        print(\"Defined my_abstract_property\")\n",
    "    \n",
    "    @my_abstract_property.setter\n",
    "    def my_abstract_property(self, val):\n",
    "        print(\"Defined my_abstract_property setter\")\n",
    "Child_C2_instance = Child_C2()\n",
    "print(issubclass(Child_C2, C))\n",
    "print(isinstance(Child_C2_instance, C))\n",
    "print(Child_C2.__bases__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "86be8565",
   "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.9.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}