18_Class.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5ed5b7df-154d-495e-a3e1-39cddaf06395",
   "metadata": {},
   "source": [
    "# inheritance"
   ]
  },
  {
   "cell_type": "raw",
   "id": "dffcbea6-9353-47b0-bf8c-7a662e7fc931",
   "metadata": {},
   "source": [
    "رابطه:\n",
    "is a\n",
    "\n",
    "باعث میشه کدها را دیگر تکرار نکنیم\n",
    "\n",
    "ما هدفمون اینه یک کلاس انتزاعی تر داشته باشیم برای اینکه متد و ارتیبیوت های مشترک\n",
    "\n",
    "\n",
    "هرکلاسی در پایتون به صورت خودکار از کلاسی بنام آبجکت ارثبری میکنند\n",
    "object\n",
    "که یکسری رفتار و متا دیتا به کلاس موردنظر اضافه میکند\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "3c1ef4d3-6e20-4929-88a0-141292becac6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'object'>\n"
     ]
    }
   ],
   "source": [
    "# براینکه بفهمیم یک کلاس از چه کلاس هایی ارثبری کرده\n",
    "\n",
    "class Example:\n",
    "    pass\n",
    "\n",
    "print(Example.__base__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1313e998-22b7-4474-b0e3-1516f7c50578",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'object'>\n"
     ]
    }
   ],
   "source": [
    "# برای ارث بری\n",
    "\n",
    "class Example(object):\n",
    "    pass\n",
    "\n",
    "# میتونیم کلاس آبجکت را بنویسیم یا ننویسیم\n",
    "\n",
    "print(Example.__base__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e44ecc5a-6e0b-4460-b149-26405c804114",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ali\n",
      "[Seller('ali', 23)]\n"
     ]
    }
   ],
   "source": [
    "# کلاس فرزند تمام متدها و اتریبیوت های کلاس پدر را دارد\n",
    "# به اتریبویت های کلاس نیز دسترسی داریم در فرزند\n",
    "from typing import List\n",
    "\n",
    "class User:\n",
    "    all_users: List[\"User\"] = []\n",
    "    def __init__(self, name:str ,age:int) -> None:\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        User.all_users.append(self)\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return f\"{self.__class__.__name__}({self.name!r}, {self.age})\"\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f\"{self.name}\"\n",
    "    \n",
    "    \n",
    "class Seller(User):\n",
    "    def order(self, order: \"Order\") -> None:\n",
    "        print(f\"{self.name} ,your {order} ordred\")\n",
    "\n",
    "s1 = Seller(\"ali\", 23)\n",
    "print(s1)\n",
    "print(s1.all_users)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "288e1473-8dee-4db7-94cb-54047f8c9d97",
   "metadata": {},
   "source": [
    "# inheritance from buildtins"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "7b7dc5e0-6611-410a-a78d-c3567eedbfe0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "# در واقع داریم یک آبجکت از آن کلاس میسازیم\n",
    "\n",
    "y = list()\n",
    "x = int()\n",
    "\n",
    "print(x)\n",
    "\n",
    "# در اینجا میخاهیم یک قابلیت جدید به متدهای داخلی کلاس ها اضافه بکنیم\n",
    "# تغییر متدهای دیفالت این کلاس ها نیاز به دانش درباره آن متد ها و ریسک بالایی دارد"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "6454dcac-e030-49dd-ab2f-6902c7898e7f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__module__', '__mul__', '__ne__', '__new__', '__orig_bases__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'search', 'sort']\n",
      "\n",
      "[User('ali', 3), User('amir', 12), User('alis', 23)]\n",
      "\n",
      "[User('ali', 3), User('alis', 23)]\n"
     ]
    }
   ],
   "source": [
    "from typing import List\n",
    "from pprint import pprint\n",
    "\n",
    "class UserList(list[\"User\"]):\n",
    "    def search(self, user_name: str) -> list[\"User\"]:\n",
    "        matching_users: list[\"User\"] = []\n",
    "        for user in self:\n",
    "            if user_name in user.name:\n",
    "                matching_users.append(user)\n",
    "        return matching_users\n",
    "    \n",
    "class User:\n",
    "    all_users: list[\"User\"] = UserList()\n",
    "    def __init__(self, name:str ,age:int) -> None:\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        User.all_users.append(self)\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return f\"{self.__class__.__name__}({self.name!r}, {self.age})\"\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f\"{self.name}\"\n",
    "\n",
    "\n",
    "# برای اینکه مشخص بکنیم عناصر لیست چی هستند از کلاس یوزر استفاده میکنیم   \n",
    "# class UserList(list):\n",
    "\n",
    "# حالا میتونیم بجای لیست خود پایتون از این لیست استفاده بکنیم\n",
    "    \n",
    "    \n",
    "print(dir(UserList))\n",
    "# میبینیم که متدهای تایپ(کلاس) لیست ها را دارد\n",
    "\n",
    "print()\n",
    "\n",
    "user1 = User(\"ali\", 3)\n",
    "user2 = User(\"amir\", 12)\n",
    "user3 = User(\"alis\", 23)\n",
    "    \n",
    "pprint(User.all_users)\n",
    "    \n",
    "print()\n",
    "\n",
    "pprint(User.all_users.search(\"ali\"))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aacd9ef8-4767-4412-8946-a3ba80ed1c78",
   "metadata": {},
   "source": [
    "# overriding - super"
   ]
  },
  {
   "cell_type": "raw",
   "id": "c9a76300-0a19-4adf-a6f5-a8ab6e0e1113",
   "metadata": {},
   "source": [
    "overriding\n",
    "تغییر رفتار در متدها\n",
    "تغییر یا جایگزینی یک متد در سوپر کلاس در زیر کلاس\n",
    "\n",
    "اگر یکی از متدهای سوپر کلاس را در زیر کلاس بنویسیم به صورت خود به خود اوررایت میشود\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "9eba72d9-fde5-44b3-a0ee-9a3d9c0815e0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0939\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'Buyer' object has no attribute 'name'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[5], line 22\u001b[0m\n\u001b[1;32m     19\u001b[0m buyer \u001b[38;5;241m=\u001b[39m Buyer(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m0939\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m     21\u001b[0m \u001b[38;5;28mprint\u001b[39m(buyer\u001b[38;5;241m.\u001b[39mphone)\n\u001b[0;32m---> 22\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mbuyer\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mname\u001b[49m)\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'Buyer' object has no attribute 'name'"
     ]
    }
   ],
   "source": [
    "\n",
    "class User:\n",
    "    all_users: list[\"User\"] = []\n",
    "    def __init__(self, name:str ,age:int) -> None:\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        User.all_users.append(self)\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return f\"{self.__class__.__name__}({self.name!r}, {self.age})\"\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f\"{self.name}\"\n",
    "\n",
    "    \n",
    "class Buyer(User):\n",
    "    def __init__(self, phone:str) -> None:\n",
    "        self.phone = phone\n",
    "        \n",
    "buyer = Buyer(\"0939\")\n",
    "\n",
    "print(buyer.phone)\n",
    "print(buyer.name)\n",
    "\n",
    "# در اینجا درواقع اومدیم از یوزر ارثبری کردیم اما اتریبیوت نام که در یوزر بوده در بایر وجود ندارد\n",
    "# در واقع ما در اینجا اینیت را اوررایت کرده اییم\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "fe694162-d074-492c-9074-c7963ac2962e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0939\n",
      "ali\n",
      "[User('reza0', 14), Buyer('ali', 45)]\n"
     ]
    }
   ],
   "source": [
    "# راه اول اینه همان مقداردهی های اولیه را که در سوپر کلاس انجام دادیم اینجا نیز انجام دهیم\n",
    "\n",
    "\n",
    "class User:\n",
    "    all_users: list[\"User\"] = []\n",
    "    def __init__(self, name:str ,age:int) -> None:\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        User.all_users.append(self)\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return f\"{self.__class__.__name__}({self.name!r}, {self.age})\"\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f\"{self.name}\"\n",
    "\n",
    "    \n",
    "class Buyer(User):\n",
    "    def __init__(self, name:str ,age:int ,phone:str) -> None:\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        self.phone = phone\n",
    "        User.all_users.append(self)\n",
    "\n",
    "user = User(\"reza0\", 14)\n",
    "buyer = Buyer(\"ali\" ,45 ,\"0939\")\n",
    "\n",
    "print(buyer.phone)\n",
    "print(buyer.name)\n",
    "print(User.all_users)\n",
    "# همانطور که میبینید به تمام یوزرها حتی زیرکلاس دسترسی دارد"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "86a02b0b-4ea7-420e-88c0-41d028fd6953",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0939\n",
      "ali\n",
      "[User('reza0', 14), Buyer('ali', 45, 0939)]\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# super\n",
    "# دسترسی میدهد به کلاس پدر\n",
    "# درواقع یک شی موقت از کلاس پدر میسازد و ما باستفاده از اون به پراپرتی ها و متد های آن دسترسی داریم\n",
    "# سوپر ار میتوانیم در هر یک از متد ها زیرکلاس فراخونی کرد برای دسترسی به متد ها و اتریبیوت های پدر\n",
    "\n",
    "class User:\n",
    "    all_users: list[\"User\"] = []\n",
    "    def __init__(self, name:str ,age:int) -> None:\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        User.all_users.append(self)\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return f\"{self.__class__.__name__}({self.name!r}, {self.age})\"\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f\"{self.name}\"\n",
    "\n",
    "    \n",
    "class Buyer(User):\n",
    "    def __init__(self, name:str ,age:int ,phone:str) -> None:\n",
    "        # در نسخه های جدید نیازی به ورودی های خود سوپر نیست\n",
    "        \n",
    "        # باید مقادیری که آبجکت یوزر داشته باشد بفرستیم\n",
    "        # super(Buyer, self).__init__(name , age)\n",
    "        super().__init__(name , age)\n",
    "        self.phone = phone\n",
    "        \n",
    "    def __repr__(self):\n",
    "        return f\"{self.__class__.__name__}({self.name!r}, {self.age}, {self.phone})\"\n",
    "    \n",
    "\n",
    "user = User(\"reza0\", 14)\n",
    "buyer = Buyer(\"ali\" ,45 ,\"0939\")\n",
    "\n",
    "print(buyer.phone)\n",
    "print(buyer.name)\n",
    "print(User.all_users)\n",
    "\n",
    "# isinstance()\n",
    "# بررسی میکند آیا یک آبجکت از یک نمونه ایی از کلاس یا تایپ است یا ن\n",
    "print(isinstance(buyer, User))\n",
    "print(isinstance(user, Buyer))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "c5d4dea0-26e3-4b6a-ab78-2c38dc3d30a5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[User('ali', 3)]\n"
     ]
    }
   ],
   "source": [
    "from typing import List\n",
    "from pprint import pprint\n",
    "\n",
    "class UserList(List):\n",
    "    def search(self, user_name: str) -> list[\"User\"]:\n",
    "        matching_users: list[\"User\"] = []\n",
    "        for user in self:\n",
    "            if user_name in user.name:\n",
    "                matching_users.append(user)\n",
    "        return matching_users\n",
    "    \n",
    "    def append(self, obj) -> None:\n",
    "        if not isinstance(obj, User):\n",
    "            raise TypeError(\"this is not type of User\")\n",
    "        # در اینجا نمیتونیم از سلف استفاده بکنیم زیرا به خود اپند همین کلاس اشاره میکند    \n",
    "        # return self.append(obj) -> Error\n",
    "        return super().append(obj)\n",
    "    \n",
    "    \n",
    "class User:\n",
    "    all_users: list[\"User\"] = UserList()\n",
    "    def __init__(self, name:str ,age:int) -> None:\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        User.all_users.append(self)\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return f\"{self.__class__.__name__}({self.name!r}, {self.age})\"\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f\"{self.name}\"\n",
    "    \n",
    "\n",
    "user1 = User(\"ali\", 3)\n",
    "li = UserList()\n",
    "li.append(user1)\n",
    "    \n",
    "pprint(li)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e542eb60-0195-414b-a575-5e3bb536d619",
   "metadata": {},
   "source": [
    "# multiple inheritance"
   ]
  },
  {
   "cell_type": "raw",
   "id": "5968bb50-147a-43f8-bc18-8efb8af112f6",
   "metadata": {},
   "source": [
    "چطور از چنتا کلاس بصورت همزمان ارث بری کنیم\n",
    "\n",
    "با اینکه در عمل ساده است اما در باطن ممکن است مشکلاتی داشته باشد\n",
    "\n",
    "خیلی رایج نیست و حساسیت بالا دارد\n",
    "\n",
    "بزرگترین مشکل این است که دوتا کلاسی که ازآن ارثبری میکنیم از یک کلاس ارثبری کرده باشند\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "8221db63-d543-4f15-b768-4dde947d7296",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.SubClass object at 0x7f833a41fb80>\n",
      "<__main__.SubClass object at 0x7f833a41fb80>\n"
     ]
    }
   ],
   "source": [
    "class SuperClass1:\n",
    "    def print1(self):\n",
    "        print(self)\n",
    "    pass\n",
    "\n",
    "class SuperClass2:\n",
    "    def print2(self):\n",
    "        print(self)\n",
    "    pass\n",
    "\n",
    "class SubClass(SuperClass1, SuperClass2):\n",
    "    pass\n",
    "\n",
    "obj = SubClass()\n",
    "obj.print1()\n",
    "obj.print2()\n",
    "\n",
    "# آبجکت ها در یک نقطه از حافظه وجود دارند زیرا یک آبجکت است و تغییری نمیکند\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "87d00e35-7634-468b-8d86-da22a310b42c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SuperClass1\n",
      "<__main__.SubClass1 object at 0x7f833a848310>\n",
      "SuperClass2\n",
      "<__main__.SubClass2 object at 0x7f833a848580>\n"
     ]
    }
   ],
   "source": [
    "# مشکل زمانی ایجاد میشود که دوتا متد با اسم یکسان دارند\n",
    "\n",
    "class SuperClass1:\n",
    "    def print(self):\n",
    "        print(\"SuperClass1\")\n",
    "        print(self)\n",
    "    pass\n",
    "\n",
    "class SuperClass2:\n",
    "    def print(self):\n",
    "        print(\"SuperClass2\")\n",
    "        print(self)\n",
    "    pass\n",
    "\n",
    "class SubClass1(SuperClass1, SuperClass2):\n",
    "    pass\n",
    "\n",
    "class SubClass2(SuperClass2, SuperClass1):\n",
    "    pass\n",
    "\n",
    "obj1 = SubClass1()\n",
    "obj2 = SubClass2()\n",
    "\n",
    "obj1.print()\n",
    "obj2.print()\n",
    "\n",
    "# همانطور که میبیند از اول کلاسی که ارثبری میکند متد را نمایش میدهد\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "7a67bc01-d73c-403b-bfec-5efe7b385e92",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'SubClass' object has no attribute 'p1'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[32], line 17\u001b[0m\n\u001b[1;32m     15\u001b[0m obj \u001b[38;5;241m=\u001b[39m SubClass(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m)\n\u001b[1;32m     16\u001b[0m \u001b[38;5;28mprint\u001b[39m(obj\u001b[38;5;241m.\u001b[39mp2)\n\u001b[0;32m---> 17\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mobj\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mp1\u001b[49m)\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'SubClass' object has no attribute 'p1'"
     ]
    }
   ],
   "source": [
    "class SuperClass1:\n",
    "    def __init__(self, p1):\n",
    "        self.p1 = p1\n",
    "\n",
    "class SuperClass2:\n",
    "    def __init__(self, p2):\n",
    "        self.p2 = p2\n",
    "\n",
    "class SubClass(SuperClass2, SuperClass1):\n",
    "    def __init__(self,p1 ,p3):\n",
    "        super(SubClass, self).__init__(p1)\n",
    "        self.p3 = p3\n",
    "\n",
    "\n",
    "obj = SubClass(1, 2)\n",
    "print(obj.p2)\n",
    "print(obj.p1)\n",
    "\n",
    "# مقداردهی را برای گزینه اول انجام داده است\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "c7090c6d-657f-4a2d-baaf-7ea61f05f8fd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "# حل مشکل\n",
    "\n",
    "class SuperClass1:\n",
    "    def __init__(self, p1):\n",
    "        self.p1 = p1\n",
    "\n",
    "class SuperClass2:\n",
    "    def __init__(self, p2):\n",
    "        self.p2 = p2\n",
    "\n",
    "class SubClass(SuperClass2, SuperClass1):\n",
    "    def __init__(self,p1 ,p2 ,p3):\n",
    "        # برای اینکه مشخص شود برای کدوم آبجکت است سلف را میفرستیم\n",
    "        SuperClass1.__init__(self, p1)\n",
    "        SuperClass2.__init__(self, p2)\n",
    "        self.p3 = p3\n",
    "\n",
    "\n",
    "obj = SubClass(1, 2, 3)\n",
    "print(obj.p3)\n",
    "print(obj.p2)\n",
    "print(obj.p1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36f1600b-1815-46d6-a475-1eae27782579",
   "metadata": {},
   "source": [
    "# diamond - MRO"
   ]
  },
  {
   "attachments": {
    "Screenshot%20from%202023-07-24%2017-47-30.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "dc0d7732",
   "metadata": {},
   "source": [
    "![Screenshot%20from%202023-07-24%2017-47-30.png](attachment:Screenshot%20from%202023-07-24%2017-47-30.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "a53bc868-0792-4794-b094-3e8b8c9b7700",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "call on base class\n",
      "call on base class\n",
      "0\n",
      "1\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "class BaseClass:\n",
    "    num_base_cell = 0\n",
    "    \n",
    "    def call_me(self):\n",
    "        print(\"call on base class\")\n",
    "        # چطور این متغییر کلاس به متغییر آبجکت تبدیل میشود\n",
    "        self.num_base_cell += 1\n",
    "        \n",
    "object1 = BaseClass()\n",
    "object1.call_me()\n",
    "\n",
    "object2 = BaseClass()\n",
    "object2.call_me()\n",
    "\n",
    "print(BaseClass.num_base_cell)\n",
    "print(object1.num_base_cell)\n",
    "print(object2.num_base_cell)\n",
    "\n",
    "# ابتدا وقتی به این عبارت میرسد\n",
    "# self.num_base_cell += 1\n",
    "# تبدیل به این میکند\n",
    "# self.num_base_cell = self.num_base_cell + 1\n",
    "# self.num_base_cell = 0 + 1\n",
    "# و با توجه به این یک متغییر نمونه جدید میسازد و به متغییر کلاس توجهی ندارد\n",
    "# self.num_base_cell = 1\n",
    "\n",
    "# متغییر نمونه را نوشتیم زیرا دفعه اول از آن متغییر استفاده بکند"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "40ee70c8-2297-4fd7-8f3b-acf05742e24e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "call on base class\n",
      "call on left class\n",
      "call on base class\n",
      "call on right class\n",
      "call on sub class\n",
      "1 1 1 2\n"
     ]
    }
   ],
   "source": [
    "\n",
    "class BaseClass:\n",
    "    num_base_cell = 0\n",
    "    \n",
    "    def call_me(self):\n",
    "        print(\"call on base class\")\n",
    "        self.num_base_cell += 1\n",
    "\n",
    "        \n",
    "class LeftSubClass(BaseClass):\n",
    "    num_left_cell = 0\n",
    "    \n",
    "    def call_me(self):\n",
    "        BaseClass.call_me(self)\n",
    "        print(\"call on left class\")\n",
    "        self.num_left_cell += 1\n",
    "\n",
    "class RightSubClass(BaseClass):\n",
    "    num_right_cell = 0\n",
    "    \n",
    "    def call_me(self):\n",
    "        BaseClass.call_me(self)\n",
    "        print(\"call on right class\")\n",
    "        self.num_right_cell += 1\n",
    "\n",
    "        \n",
    "class SubClass(LeftSubClass, RightSubClass):\n",
    "    num_sub_cell = 0\n",
    "    \n",
    "    def call_me(self):\n",
    "        LeftSubClass.call_me(self)\n",
    "        RightSubClass.call_me(self)\n",
    "        print(\"call on sub class\")\n",
    "        self.num_sub_cell += 1\n",
    "\n",
    "s = SubClass()\n",
    "s.call_me()\n",
    "print(s.num_sub_cell, s.num_left_cell, s.num_right_cell ,s.num_base_cell)\n",
    "\n",
    "# همانطور که میبینید بیس کلاس دو مرتبه اجرا شده است زیرا با توجه به ترتیبی که خودممون ایجاد کردیم دومرتبه فراخوانده میشود\n",
    "\n",
    "# راه حل\n",
    "# mro"
   ]
  },
  {
   "cell_type": "raw",
   "id": "5351030c-eb5d-495e-89aa-6f575e3ff7ef",
   "metadata": {},
   "source": [
    "mro\n",
    "\n",
    "method resulation order\n",
    "\n",
    "الگوریتمی که باعث میشود خودش براساس قانونین خاصی این ترتیب را مشخص میکند\n",
    "\n",
    "با کمک این نیازی نیست بفهمیم ترتیب به چه شکل است\n",
    "\n",
    "وظیفه آن این است که وقتی ما یک ساختار پیچیده داریم میاد ترتیب اجرا را در یک تاپل  به صورت خطی که تکراری وجود ندارد\n",
    "\n",
    "متد سوپر این کار را با توجه به الگوریتم سوپر انجام میدهد\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "bb74a015-3130-4b4a-8154-b00ecd0cfb3b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "call on base class\n",
      "call on right class\n",
      "call on left class\n",
      "call on sub class\n",
      "1 1 1 1\n",
      "\n",
      "(<class '__main__.SubClass'>,\n",
      " <class '__main__.LeftSubClass'>,\n",
      " <class '__main__.RightSubClass'>,\n",
      " <class '__main__.BaseClass'>,\n",
      " <class 'object'>)\n"
     ]
    }
   ],
   "source": [
    "import pprint\n",
    "\n",
    "class BaseClass:\n",
    "    num_base_cell = 0\n",
    "    \n",
    "    def call_me(self):\n",
    "        print(\"call on base class\")\n",
    "        self.num_base_cell += 1\n",
    "\n",
    "        \n",
    "class LeftSubClass(BaseClass):\n",
    "    num_left_cell = 0\n",
    "    \n",
    "    def call_me(self):\n",
    "        super().call_me()\n",
    "        print(\"call on left class\")\n",
    "        self.num_left_cell += 1\n",
    "\n",
    "class RightSubClass(BaseClass):\n",
    "    num_right_cell = 0\n",
    "    \n",
    "    def call_me(self):\n",
    "        super().call_me()\n",
    "        print(\"call on right class\")\n",
    "        self.num_right_cell += 1\n",
    "\n",
    "        \n",
    "class SubClass(LeftSubClass, RightSubClass):\n",
    "    num_sub_cell = 0\n",
    "    \n",
    "    def call_me(self):\n",
    "        super().call_me()\n",
    "        print(\"call on sub class\")\n",
    "        self.num_sub_cell += 1\n",
    "\n",
    "s = SubClass()\n",
    "s.call_me()\n",
    "print(s.num_sub_cell, s.num_left_cell, s.num_right_cell ,s.num_base_cell)\n",
    "\n",
    "# اما در اینجا ترتیب مهم نیست راست یا چپ\n",
    "\n",
    "# برای دیدن ام ار او\n",
    "print()\n",
    "pprint.pprint(SubClass.__mro__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98f8bc1d-9c98-4321-97fe-b8dbb357bf2c",
   "metadata": {},
   "source": [
    "# initializeation in multiple inheritance"
   ]
  },
  {
   "cell_type": "raw",
   "id": "13730ac2-0a93-4e72-a4a6-b957ffea2d17",
   "metadata": {},
   "source": [
    "چطور ار سوپر در مقداردهی اولیه استفاده بکنیم"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "04ec5fe6-3fd9-489a-ac1a-998d2c0346a5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6 7 2 3 4 5 1\n"
     ]
    }
   ],
   "source": [
    "# در این راه حل روش و ترتیب فرستان آرگومان ها مهم است\n",
    "\n",
    "class BaseClass:\n",
    "    num_base_cell = 0\n",
    "    \n",
    "    def __init__(self, a, b, *args):\n",
    "        self.a = a\n",
    "        self.b = b\n",
    "    \n",
    "    def call_me(self):\n",
    "        print(\"call on base class\")\n",
    "        self.num_base_cell += 1\n",
    "\n",
    "        \n",
    "class LeftSubClass(BaseClass):\n",
    "    num_left_cell = 0\n",
    "    \n",
    "    def __init__(self, c, *args):\n",
    "        super().__init__(*args)\n",
    "        self.c = c\n",
    "        \n",
    "    def call_me(self):\n",
    "        super().call_me()\n",
    "        print(\"call on left class\")\n",
    "        self.num_left_cell += 1\n",
    "\n",
    "class RightSubClass(BaseClass):\n",
    "    num_right_cell = 0\n",
    "    \n",
    "    def __init__(self, d, e, f, *args):\n",
    "        super().__init__(*args)\n",
    "        self.d = d\n",
    "        self.e = e\n",
    "        self.f = f\n",
    "        \n",
    "    def call_me(self):\n",
    "        super().call_me()\n",
    "        print(\"call on right class\")\n",
    "        self.num_right_cell += 1\n",
    "\n",
    "        \n",
    "class SubClass(LeftSubClass, RightSubClass):\n",
    "    num_sub_cell = 0\n",
    "    \n",
    "    def __init__(self, g, *args):\n",
    "        super().__init__(*args)\n",
    "        self.g = g\n",
    "        \n",
    "    def call_me(self):\n",
    "        super().call_me()\n",
    "        print(\"call on sub class\")\n",
    "        self.num_sub_cell += 1\n",
    "\n",
    "s = SubClass(1, 2, 3, 4, 5, 6, 7)\n",
    "print(s.a, s.b,s.c ,s.d ,s.e ,s.f ,s.g )\n",
    "# در اینجا ترتیب خیلی مهم است و باید ترتیب ام آر او را دانست\n",
    "\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "7b7d375e-2261-4b89-aed9-67af72315357",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 6 7\n"
     ]
    }
   ],
   "source": [
    "# براینکه اهمیت ترتیب را کمتر بکنیم بجای آرگز از کیورد آرگز استفده بکنیم\n",
    "\n",
    "class BaseClass:\n",
    "    num_base_cell = 0\n",
    "    \n",
    "    def __init__(self, a, b ,**kwargs):\n",
    "        self.a = a\n",
    "        self.b = b\n",
    "    \n",
    "    def call_me(self):\n",
    "        print(\"call on base class\")\n",
    "        self.num_base_cell += 1\n",
    "\n",
    "        \n",
    "class LeftSubClass(BaseClass):\n",
    "    num_left_cell = 0\n",
    "    \n",
    "    def __init__(self, c, **kwargs):\n",
    "        super().__init__(**kwargs)\n",
    "        self.c = c\n",
    "        \n",
    "    def call_me(self):\n",
    "        super().call_me()\n",
    "        print(\"call on left class\")\n",
    "        self.num_left_cell += 1\n",
    "\n",
    "class RightSubClass(BaseClass):\n",
    "    num_right_cell = 0\n",
    "    \n",
    "    def __init__(self, d, e, f, **kwargs):\n",
    "        super().__init__(**kwargs)\n",
    "        self.d = d\n",
    "        self.e = e\n",
    "        self.f = f\n",
    "        \n",
    "    def call_me(self):\n",
    "        super().call_me()\n",
    "        print(\"call on right class\")\n",
    "        self.num_right_cell += 1\n",
    "\n",
    "        \n",
    "class SubClass(LeftSubClass, RightSubClass):\n",
    "    num_sub_cell = 0\n",
    "    \n",
    "    def __init__(self, g, **kwargs):\n",
    "        super().__init__(**kwargs)\n",
    "        self.g = g\n",
    "        \n",
    "    def call_me(self):\n",
    "        super().call_me()\n",
    "        print(\"call on sub class\")\n",
    "        self.num_sub_cell += 1\n",
    "\n",
    "s = SubClass(a=1, b=2, c=3, d=4, e=5, f=6, g=7)\n",
    "print(s.a, s.b,s.c ,s.d ,s.e ,s.f ,s.g )\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ca58ff4-f7c6-4682-be39-18ba26462fff",
   "metadata": {},
   "source": [
    "# polymorphism"
   ]
  },
  {
   "cell_type": "raw",
   "id": "9dfdeb9a-f30b-4f52-95ab-099a0f408836",
   "metadata": {},
   "source": [
    "با توجه به تایپ رفتار های متفاوت را انجام میدهد \n",
    "exaple + or len()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "14fa23d5-0ba1-446e-b422-8bfa3b74d109",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "11\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "print(len([1,2,3,4]))\n",
    "print(len(\"reza dolati\"))\n",
    "print(len({\"a\":2 ,\"b\":3}))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "01354634-feb0-46b2-8a22-2b7701010ff2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "meow...\n",
      "hi , i am a cat , my name is jack\n",
      "maa...\n",
      "hi , i am a cow , my name is jan\n",
      "\n",
      "hi , i am a cat , my name is jack\n",
      "meow...\n",
      "hi , i am a cow , my name is jan\n",
      "maa...\n"
     ]
    }
   ],
   "source": [
    "\n",
    "class Cat:\n",
    "    def __init__(self, name=\"\", color=\"\"):\n",
    "        self.name = name\n",
    "        self.color = color\n",
    "        \n",
    "    def info(self):\n",
    "        print(f\"hi , i am a cat , my name is {self.name}\")\n",
    "        \n",
    "    def make_sound(self):\n",
    "        print(\"meow...\")\n",
    "        \n",
    "        \n",
    "class Cow:\n",
    "    def __init__(self, name=\"\", color=\"\"):\n",
    "        self.name = name\n",
    "        self.color = color\n",
    "        \n",
    "    def info(self):\n",
    "        print(f\"hi , i am a cow , my name is {self.name}\")\n",
    "        \n",
    "    def make_sound(self):\n",
    "        print(\"maa...\")\n",
    "        \n",
    "cat = Cat(\"jack\", \"black\")\n",
    "cow = Cow(\"jan\", \"brown\")\n",
    "\n",
    "for animal in [cat , cow]:\n",
    "    animal.make_sound()\n",
    "    animal.info()\n",
    "# همانطور که در حلقه میبینید ما نگران نبودیم آیا متدها در حلقه هر دوتا نام یکسان در دوتا آبجکت وجود دارد و با رفتار مخصوصو خودشان\n",
    "print()\n",
    "\n",
    "def func(obj):\n",
    "    obj.info()\n",
    "    obj.make_sound()\n",
    "func(cat)\n",
    "func(cow)    \n",
    "\n",
    "# در انجا از یک تابع یکسان استفاده میکنیم اما رفتار متفاوت را ملاحظه میکنیم"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "e8be4006-3f11-40de-824f-b1123d23f91e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i cant...\n",
      "meow...\n",
      "maa...\n"
     ]
    }
   ],
   "source": [
    "# شایع ترین حالت پلی مورفیسم در ارثبری است\n",
    "\n",
    "class Animal:\n",
    "    def __init__(self, name=\"\", color=\"\"):\n",
    "        self.name = name\n",
    "        self.color = color\n",
    "        \n",
    "    def info(self):\n",
    "        print(f\"hi , i am a animal , my name is {self.name}\")\n",
    "        \n",
    "    def make_sound(self):\n",
    "        print(\"i cant...\")\n",
    "        \n",
    "        \n",
    "    \n",
    "class Cat(Animal):\n",
    "    def __init__(self, name=\"\", color=\"\"):\n",
    "        super().__init__(name, color)\n",
    "        \n",
    "    def info(self):\n",
    "        print(f\"hi , i am a cat , my name is {self.name}\")\n",
    "        \n",
    "    def make_sound(self):\n",
    "        print(\"meow...\")\n",
    "        \n",
    "        \n",
    "class Cow(Animal):\n",
    "    def __init__(self, name=\"\", color=\"\"):\n",
    "        super().__init__(name, color)\n",
    "        \n",
    "    def info(self):\n",
    "        print(f\"hi , i am a cow , my name is {self.name}\")\n",
    "        \n",
    "    def make_sound(self):\n",
    "        print(\"maa...\")\n",
    "        \n",
    "animal = Animal()        \n",
    "cat = Cat(\"jack\", \"black\")\n",
    "cow = Cow(\"jan\", \"brown\")\n",
    "\n",
    "# همانطور که میبینید متد یکسان است اما رفتار متفاوت دارند\n",
    "animal.make_sound()        \n",
    "cat.make_sound()\n",
    "cow.make_sound()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "12798c77-52d9-4b79-934b-d22ac5ad90bd",
   "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.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}