PyBasicsLearning.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "6e70ef8c",
   "metadata": {
    "tags": []
   },
   "source": [
    "<h1 style = \"text-align:center; color:red\"> Python </h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3e6a459",
   "metadata": {},
   "source": [
    "Python is a **high level**, **cross platform** language using **interpreter**."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "408248cc-7dc9-4ef1-959d-82cdd5975be1",
   "metadata": {},
   "source": [
    "- **Everything** in Python is **object** (OOP, class). \n",
    "\n",
    "Objects in Python classify into two groups:\n",
    "1. mutable : This groups can change after defining (changing of part of them) like lists.\n",
    "- mutable objects pass by-reference. \n",
    "1. immutable : This groups cannot be changed partly. For changing them, we must assign them a whole new value like strings\n",
    "- immutable objects pass by-value.\n",
    "- all function of strings do not change the main string because string is immutable, so they returns value"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85e5d6f5",
   "metadata": {},
   "source": [
    "### Debug tools in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "28b32d0c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function dir in module builtins:\n",
      "\n",
      "dir(...)\n",
      "    Show attributes of an object.\n",
      "\n",
      "    If called without an argument, return the names in the current scope.\n",
      "    Else, return an alphabetized list of names comprising (some of) the attributes\n",
      "    of the given object, and of attributes reachable from it.\n",
      "    If the object supplies a method named __dir__, it will be used; otherwise\n",
      "    the default dir() logic is used and returns:\n",
      "      for a module object: the module's attributes.\n",
      "      for a class object:  its attributes, and recursively the attributes\n",
      "        of its bases.\n",
      "      for any other object: its attributes, its class's attributes, and\n",
      "        recursively the attributes of its class's base classes.\n",
      "\n",
      "['__call__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__text_signature__']\n",
      "<class 'builtin_function_or_method'>\n",
      "['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']\n"
     ]
    }
   ],
   "source": [
    "# \"print\", \"help\", \"dir\", \"type\", \"__dict__\" (if exists)\n",
    "help(dir)\n",
    "print(dir(dir))\n",
    "print(type(dir))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb0c486f-6cca-4fd4-906c-2d150d9e0374",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "## 1. Python Interpreter Environment"
   ]
  },
  {
   "cell_type": "raw",
   "id": "6619c21e-2d24-44d9-8f98-3c0333617fa2",
   "metadata": {},
   "source": [
    ">pyhton filename.py      # for excuting a pyhton file in CMD with python interpreter."
   ]
  },
  {
   "cell_type": "raw",
   "id": "e5223e50-6f2e-464d-b00c-2642941eda17",
   "metadata": {},
   "source": [
    ">python                 # Interpreter of Python excutes in CMD of windows and terminals of linux and MAC. "
   ]
  },
  {
   "cell_type": "raw",
   "id": "212e48de-7a64-48c3-abe3-b7dabeb27e9a",
   "metadata": {},
   "source": [
    "# _ returns the value of last executed expression value in Python Prompt/Interpreter\n",
    ">>> a = 10\n",
    ">>> b = 10\n",
    ">>> _\n",
    "Traceback (most recent call last):\n",
    "File \"<stdin>\", line 1, in <module>\n",
    "NameError: name '_' is not defined\n",
    ">>> a+b\n",
    "20\n",
    ">>> _\n",
    "20\n",
    ">>> _ * 2\n",
    "40\n",
    ">>> _\n",
    "40\n",
    ">>> _ / 2\n",
    "20"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3156af56-d85f-4699-bb9d-63ab45c78684",
   "metadata": {
    "tags": []
   },
   "source": [
    "--------------------------------------\n",
    "## 2. Intro"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38b5239f-d217-4823-8106-a61204550286",
   "metadata": {},
   "source": [
    "- Python is casesensitive. <br>\n",
    "- Indexing in Python is based-0.<br>\n",
    "- All keywords of python are lowercase.<br>\n",
    "- All intervals in Python are close-open ( [start, end) ), like interval indexing\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1485c45",
   "metadata": {
    "tags": []
   },
   "source": [
    "### 2.1. Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3845b380-4637-44e0-a69d-699919cc3158",
   "metadata": {},
   "source": [
    "##### 2.1.4.4. string functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "3286cf77-c1b1-48d9-a895-3da8a6545c0e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "-1\n",
      "1\n",
      "2\n",
      "laMla\n",
      "Sala\n",
      "SalaMla\n"
     ]
    }
   ],
   "source": [
    "s = \"SalaMla\"\n",
    "print(s.find(\"la\"))   # if input string of function exists in the string, returns index of first char of first matching string.\n",
    "print(s.find(\"ali\"))  \n",
    "\n",
    "print(s.count(\"Sa\"))        # returns # of repeatance of input string in the string (string s).\n",
    "print(\"aaaaa\".count(\"aa\"))  # This function do not count overlapping.\n",
    "\n",
    "print(s.removeprefix(\"Sa\"))    # if input string exists at the begining of the string s, returns a string without input prefix. if input string do not exist at begining of main string, returns main string.\n",
    "print(s.removesuffix(\"Mla\"))   # if input string exists at the end of the string s, returns a string without input prefix. if input string do not exist at the end of main string, returns main string.\n",
    "\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b46091a",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "-------------------------------\n",
    "### 2.2. I/O "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d6b4f69-aa52-465c-a2b9-b5f8b778355e",
   "metadata": {},
   "source": [
    "#### 2.2.1. Input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8289f763",
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "# Python always gets all line as input in type of String\n",
    "yourName = input(\"Enter your name: \") # The string in () \n",
    "yourAge = int(input(\"Enter your age: \"))\n",
    "\n",
    "p, d = re.split(' ', input()) # gets two string in one line which seperates form each other by space\n",
    "p = int(p)\n",
    "d = int(d) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5360986d-cf66-41a0-ba86-151fd4f7edd4",
   "metadata": {},
   "source": [
    "#### 2.2.2. Output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "09b5b80c-5d55-4b09-aacb-364347e2daee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "helloWorld\n",
      "Salam Khoobi\n"
     ]
    }
   ],
   "source": [
    "print(\"helloWorld\") # print instruction moves to next line after printing as default. \n",
    "\n",
    "print(\"Salam\", end = \" \") # default of \"end\" is \\n . \n",
    "print(\"Khoobi\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38017947-59e5-4c1b-847b-66444ef2b1e6",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "---------------------------\n",
    "### 2.3. namespace"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39fe87d2-41c1-4f6e-a481-6fa325b42a1f",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "یک سیستم نامگذاری برای متمایز کردن نام خصوصیت‌ها و متغیرها استفاده می‌شود. یک کلاس و یا همچنین متغیرهای محلی (local) هر تابع نیز تشکیل یک فضای نام می‌دهند. به طور مثال فرض کنید در یک کلاس چند دانش‌آموز با نام رضا وجود دارد. در این صورت برای متمایز کردن آن‌ها به نام خانوادگی‌شان نیز نیاز داریم. به طور مثال اگر فرد موردنظر شما رضا کریمی باشد، حتما باید نام خانوادگی او را نیز صدا بزنید. اگر فقط نام او را صدا بزنید، بیشتر از یک نفر به شما پاسخ خواهند داد. چنین چیزی درباره فضای‌نام نیز کاملا صدق می‌کند. به عبارتی دو شئ می‌توانند هم اسم باشند ولی در دو فضای نام متفاوت قرار گرفته باشند، در این صورت هیچ ربطی به هم ندارند.\n",
    "<br>\n",
    "مثال زیر را در نظر بگیرید:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4066f03f-1abc-43b0-9868-d4f3fde6be52",
   "metadata": {},
   "outputs": [],
   "source": [
    "def f1():\n",
    "    x = 100\n",
    "    print(x)\n",
    "\n",
    "def f2():\n",
    "    x = 200\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55faac9c-10ec-41db-87e0-413b9ba43e21",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "در مثال بالا، در هر دو تابع، متغیر x وجود دارد، ولی چون هر کدام از آن‌ها یک فضای‌ نام جدا هستند؛ پس می‌توان از این متغیر در هر دو تابع استفاده کرد، بدون اینکه عملکرد تابع دیگری مختل شود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b77e51b-357a-4032-86ef-d9a2c6b75b80",
   "metadata": {},
   "source": [
    "#### 2.3.1. kinds of namespace"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "269422f4-5d64-4c4f-841f-a0705d60090f",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    فضای نام‌ها در زمان‌های متفاوتی ساخته می‌شوند و دارای طول‌ عمر‌های متفاوتی هستند.<br>\n",
    "    <ol>\n",
    "        <li>\n",
    "    فضای‌نام built-in (فضای نام توابع، خطا‌ها، تولید‌کننده‌ها و ... پیش‌فرض پایتون) وقتی ساخته می‌شود که مفسر پایتون شروع به کار می‌کند و تا تمام شدن برنامه باقی‌‌ می‌ماند.<br>\n",
    "        </li>\n",
    "        <li>\n",
    "    فضای‌ نام عمومی (module) وقتی شروع می‌شود که مفسر وارد تعریف آن شود و تا وقتی که مفسر از آن خارج شود باقی می‌ماند.<br>\n",
    "        </li>\n",
    "        <li>\n",
    "    فضای نام‌ محلی‌ِ یک تابع وقتی که مفسر وارد تابع می‌شود (زمانی که یک تابع فراخوانی شود) ساخته می‌شود و وقتی تابع مقداری را برگرداند و یا دچار یک خطا شود (خطایی که درون تابع مدیریت (handle) نشده باشد) از بین می‌رود. بنابراین هر کدام از لایه‌های توابع بازگشتی دارای فضای‌ نام محلی‌ جدایی هستند.\n",
    "        </li>\n",
    "    </ol>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2c466f6-4b73-49f2-93c1-befd8e187abf",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "--------------------------------------------\n",
    "### 2.4. Scope (of objects)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5147d73-bf4a-4024-a880-5fce2d682f25",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\" >\n",
    "    در پایتون برای تعریف محدوده (Scope) باید تمام دستورات درون آن محدوده را با فاصله بیش‌تر نسبت به دستور قبل از شروع محدوده بنویسیم (قبل از آن‌ها یک Tab اضافه می‌گذاریم). درواقع پایتون با فاصله، ساختار می‌یابد. در صورتی هم که این کار را انجام ندهیم مفسر خطا داده و برنامه اجرا نمی‌شود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3b7c3b00-6256-4781-8bd0-d5d4b24f2ba8",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 10\n",
    "def f():\n",
    "    if x % 2 == 0:\n",
    "        print(\"even\")\n",
    "        pass\n",
    "    else:\n",
    "        print(\"odd\")\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3212c021-186c-49bf-b2eb-e341c0a447dc",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\" >\n",
    "    هم‌چنین در ادامه‌ی تمامی دستورات کنترلی در محدوده‌ی آن‌ها حتما باید دستوری برای اجرا نوشته شود (اگر محدوده خالی باشد خطای IndentationError برگردانده می شود). در صورتی که نخواهیم در محدوده‌ای چیزی اجرا شود، می‌توانیم دستور pass را به تنهایی در آن محدوده قرار دهیم. این دستور به مفسر می‌گوید بدون انجام هیچ کاری از این خط عبور کن.\n",
    "    <br>\n",
    "    <li>\n",
    "    برای به اتمام رساندن یک scope  حتما از pass استفاده می کنیم.\n",
    "    </li>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "887ee8b4-63f8-4273-8185-8e74ba58b50d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def f():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2de71526-6d73-4157-b657-a58cc80bf662",
   "metadata": {},
   "source": [
    "#### 2.4.1. local scope"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b045fa1a-78b0-47f2-930e-110874086b82",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "درونی‌ترین محدوده که شامل متغیر‌های محلی می‌شود. به عبارتی متغیری که درون یک تابع تعریف می‌شود و فقط از درون همان تابع قابل دسترس باشد در این محدوده قرار دارد. به مثال زیر توجه کنید:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "07fd5b2c-ad7e-47ed-a3f1-45366edb29af",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'xl' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_6064/3210044435.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      4\u001b[0m     \u001b[1;32mpass\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[0mf\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 6\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mxl\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'xl' is not defined"
     ]
    }
   ],
   "source": [
    "def f():\n",
    "    xl = 100\n",
    "    print(xl)\n",
    "    pass\n",
    "f()\n",
    "print(xl)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e55b368c-60e6-41b1-83c6-3c55b296dda0",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "متغیر xl بیرون از محدوده تابع در دسترس نیست.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65a75c49-a530-4c30-8468-7b55e1a8806d",
   "metadata": {},
   "source": [
    "#### 2.4.2. global scope"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3439462e-6145-44aa-ba49-59de8bb2eaa7",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "وقتی متغیری درون این محدوده تعریف شود در جای‌‌جای فایل یا اسکریپت پایتونی مربوطه در دسترس می‌باشد. برای درک این موضوع به مثال زیر دقت کنید:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "6c9a9b81-aabf-4e85-8a2e-191639004c2b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n",
      "100\n"
     ]
    }
   ],
   "source": [
    "xz = 100\n",
    "def f():\n",
    "    print(xz)\n",
    "f()\n",
    "print(xz)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a698a3c-e761-45c7-8021-f03ff6115f00",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "متغیر x درون محدوده محلی تابع نیز در دسترس است.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee61ea42-a48f-4f4b-885e-d94409cabd76",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "اگر نیاز به ساخت متغیر global دارید اما در محدوده‌ی محلی هستید، می‌توانید از کلمه کلیدی global استفاده کنید:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f8f45272-1ced-4d5a-8cee-d70eaba9d537",
   "metadata": {},
   "outputs": [],
   "source": [
    "def f():\n",
    "    global x\n",
    "    print(x)\n",
    "x = 100\n",
    "f()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87c1b9c3-42d2-46a6-83b3-151c8faee904",
   "metadata": {},
   "source": [
    "#### 2.4.3. built-in scope"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0277843c-a5a8-4494-9b16-7afdaff40a10",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "توابعی مثل print() و id() به محض اجرای مفسر در تمامی نقاط اسکریپت یا فایل مربوطه قابل دسترس هستند که در فضای نام built-in قرار می‌گیرند. این یعنی شما می‌توانید این توابع را هرکجای کدتان استفاده کنید. در ضمن این محدوده دارای بیشترین طول عمر می‌باشد.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9575606-9a6a-45b8-a5d2-9003dfc03dc7",
   "metadata": {},
   "source": [
    "#### 2.4.4. non-local variables"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3dd41bd-e000-4124-8319-5074a3312d02",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    " حال نوبت به متغیرهای غیرمحلی می‌رسد:\n",
    "<br>\n",
    "کلمه کلیدی nonlocal برای دسترسی به متغیرهای درون توابع تودرتو استفاده می‌شود، هنگامی که متغیر تابع داخلی متعلق به تابع بیرونی است. برنامه زیر را در نظر بگیرید. اگر بخواهیم در تابع g به متغیر age که درون تابع f قرار دارد دسترسی داشته باشیم از کلمه کلیدی nonlocal استفاده می‌کنیم.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c7ef739f-278e-469e-9ee0-bd0e7cb2ee0d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mohammad 10\n",
      "saeid 15\n",
      "mohammad 15\n"
     ]
    }
   ],
   "source": [
    "def f():\n",
    "    name = 'mohammad'\n",
    "    age = 10\n",
    "    def g():\n",
    "        name = 'saeid'\n",
    "        nonlocal age\n",
    "        age = 15\n",
    "        print(name, age)\n",
    "        pass\n",
    "    print(name, age)\n",
    "    g()\n",
    "    print(name, age)\n",
    "    pass\n",
    "\n",
    "f()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6f46db8-ce07-4271-b56e-febe10c656ec",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "در مثال زیر، نحوه‌ی استفاده از متغیرهای local, globalو nonlocal را در کنار هم می‌بینید و می‌توانید مقایسه کنید.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e65d193c-8df8-4f7f-b48d-68da504fd820",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "in function: khoobi?\n",
      "salam\n",
      "in function: chetori?\n",
      "chetori?\n",
      "in function: chera?!\n",
      "chetori?\n",
      "chera?!\n"
     ]
    }
   ],
   "source": [
    "def test():\n",
    "\n",
    "    msg= \"salam\"\n",
    "\n",
    "    def test_local():\n",
    "        msg = \"khoobi?\"\n",
    "        print(\"in function: \" + msg)\n",
    "\n",
    "    def test_nonlocal():\n",
    "        nonlocal msg\n",
    "        msg = \"chetori?\"\n",
    "        print(\"in function: \" + msg)\n",
    "\n",
    "    def test_global():\n",
    "        global msg\n",
    "        msg = \"chera?!\"\n",
    "        print(\"in function: \" + msg)\n",
    "\n",
    "    test_local()\n",
    "    print(msg)\n",
    "    test_nonlocal()\n",
    "    print(msg)\n",
    "    test_global()\n",
    "    print(msg)\n",
    "\n",
    "test()\n",
    "print(msg)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8daceca-2252-4e24-afe3-033b3dd423ab",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "ابتدا تابع test() صدا زده می‌شود؛ در این تابع، ابتدا تابع test_local() صدا زده می‌شود. در این تابع یک متغیر محلی تعریف شده و درخط بعد مقدار عبارت موردنظر چاپ می‌شود که برابر in function: khoobi? است (چون متغیر محلی است، پس تغییری در متغیر msg که در خط ۳ تعریف شده،‌ ایجاد نمی‌شود). و در نهایت نیز چون مقدار msg که در خط ۳ است تغییری نکرده، پس print خط ۲۰، مقدار salam را چاپ می‌کند.\n",
    "<br>\n",
    "پس از آن،‌ تابع test_nonlocal() صدا زده می‌شود. در این تابع یک متغیر غیرمحلی تعریف شده، به این معنی که هر مقداری که داخل این متغیر قرار دهیم،‌ داخل متغیر msg که در خط ۳ تعریف شده نیز قرار می‌گیرد. پس مقدار msg های خطوط ۳ و ۱۱ برابر chetori? می‌شود و در خط ۱۲،‌ عبارت in function: chetori? چاپ شده و چون مقدار msg خط ۳،‌ تغییر کرده پس print خط ۲۲، مقدار chetori? را چاپ می‌کند.\n",
    "<br>\n",
    "در نهایت تابع test_global() صدا زده شده و یک متغیر گلوبال در این تابع ساخته می‌شود. پس از آن، چون مقدار این متغیر در این تابع برابر chera?! قرار داده شده؛ پس عبارت in function: chera?! چاپ می‌شود. چون تابع test() خود دارای متغیر msg است،‌ پس در خط ۲۴، همان مقدار chetori? که قبلا درون آن قرار داشت،‌ چاپ می‌شود.\n",
    "<br>\n",
    "در نهایت اجرای تابع test() تمام شده و به سراغ خط ۲۷ می‌رویم. در این خط متغیر msg باید چاپ شود ولی در این محدوده، هیچ متغیری با چنین نامی وجود ندارد. پس در برنامه به دنبال محدوده‌ای می‌گردیم که متغیر msg به صورت global تعریف شده باشد، که این اتفاق در تابع test_global() و خط ۱۵ اتفاق افتاده است. پس مقدار chera?! چاپ می‌شود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5dbf994-34ee-4cec-893c-b5bbf4620888",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "این نکته حائز اهمیت است که محدوده‌ها به صورت متنی تعریف می‌شوند و ربطی به نحوه اجرا و یا اینکه تابع از کجا صدا زده شده ندارند. محدوده تابع که درون آن متغییر‌های محلی هستند فضای متنی جلوی تابع است و فضای نام عمومی بخشی‌ست که کد تابع در آن نوشته شده.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97697d95",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "----------------------------------\n",
    "### 2.6. Function"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb129970-f823-4e61-9267-e70e19a1a86c",
   "metadata": {},
   "source": [
    "#### 2.6.1. function is an object"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15812970-be5a-4e20-a4d7-75591a02fa8e",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\" >\n",
    "    در پایتون تابع یک شی‌ء کلاس‌-اول (first-class) است. فرض کنید یک تابع به نام f دارید، سپس متغیر g را برابر با f قرار می‌دهید. حالا g دقیقا مانند f عمل می‌کند. نوعی که پایتون برای توابع در نظر می‌گیرد function است.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "168d82a6-0bb3-402e-bc70-ad9dbc0bf04f",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\" >\n",
    "    یک object در یک زبان first class هست اگر:\n",
    "<br>وقتی در ران تایم بشه ایجادش کرد \n",
    "<br>خروجی یک تابع بتونه باشه\n",
    "<br>ورودی یک تابع بتونه باشه\n",
    "    <br>\n",
    "    بر این اساس function در پایتون یک شی فرست کلاس است.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ebe8508a-bb2c-4c3b-b658-a359bfdf5f01",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "10\n",
      "<class 'function'>\n",
      "9\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "def f(a):\n",
    "    return a\n",
    "    pass\n",
    "\n",
    "\n",
    "print(f(10))\n",
    "g = f\n",
    "print(g(10))\n",
    "print(type(g))\n",
    "print(f(f(9))) \n",
    "print(f(f)(9))     # f(f) = f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "c96c02a2-c22d-40cf-a1f6-074955b0be90",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "100\n"
     ]
    }
   ],
   "source": [
    "def f(g):\n",
    "    g(10)\n",
    "    return g\n",
    "\n",
    "\n",
    "def g(a):\n",
    "    print(a)\n",
    "    pass\n",
    "\n",
    "\n",
    "f(g)(100)  # equal to g(10) because f(g) returns g"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ffb16c6c-8057-4190-ac84-2b20c10a3656",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "در مثال بالا ابتدا f(g) صدا زده می‌شود و ۱۰ چاپ می‌شود؛‌ سپس در خروجی تابع g برگردانده می‌شود و ۱۰۰ به آن ورودی داده می‌شود. بعد از آن عبارت ۱۰۰ چاپ می‌شود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ebe5679-df69-4141-bf71-e2943350ae5b",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "هم‌چنین مانند بقیه اشیا با = انتقال داده‌ می‌شوند.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "b4e374bf-daf9-4257-813e-38b87e3ce87e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "salam\n"
     ]
    }
   ],
   "source": [
    "g = print\n",
    "g(\"salam\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "071f576d-966f-448c-b0f0-3e9c379ba574",
   "metadata": {},
   "source": [
    "#### 2.6.2. function can be defined anywhere."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a2f96a1-da81-4bb7-a765-c3d3f33c560a",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "در پایتون در تمام محدوده‌ها (scope) می‌توان تابع تعریف کرد. در مثال زیر یک تابع تعریف می‌کنیم که لیستی از ضرایب را ورودی گرفته، سپس تابعی خروجی می‌دهد که محاسبه کننده یک چندجمله‌ای با همان ضرایب داده شده است.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "a010fd22-69a9-42ab-ae78-bebb32808a10",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "23\n"
     ]
    }
   ],
   "source": [
    "def poly_builder(ls):\n",
    "    def p(x):\n",
    "        ret = 0\n",
    "        for i in range(len(ls)):\n",
    "            ret += ls[i] * (x**i)\n",
    "        return ret\n",
    "    return p\n",
    "\n",
    "f = poly_builder([1, 1]) # x + 1\n",
    "print(f(-1))\n",
    "f = poly_builder([-2, 0, 1]) # x^2 - 2\n",
    "print(f(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68073f46-db48-4ed4-bfe1-8f624efcae7d",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "ه کمک کد بالا و بسط تیلور یک تابع می‌سازیم که sin را تخمین می‌زند.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "42d53c01-fd33-4617-ade3-0b1c44f914f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "math sin: \n",
      "0.49999999999999994\n",
      "our sin: \n",
      "0.49999999999999994\n"
     ]
    }
   ],
   "source": [
    "def poly_builder(ls):\n",
    "    def p(x):\n",
    "        ret = 0\n",
    "        for i in range(len(ls)):\n",
    "            ret += ls[i] * (x**i)\n",
    "        return ret\n",
    "    return p\n",
    "\n",
    "import math\n",
    "\n",
    "def fact(n):\n",
    "    if n == 0:\n",
    "        return 1\n",
    "    return fact(n-1)*n\n",
    "\n",
    "a = []\n",
    "for i in range(0, 100):\n",
    "    a.append(0)\n",
    "    if i%2 == 0:\n",
    "        continue\n",
    "    a[i] = 1.0/fact(i)\n",
    "    if int(i/2)%2 == 1:\n",
    "        a[i] *= -1\n",
    "\n",
    "sin = poly_builder(a)\n",
    "\n",
    "print('math sin: ')\n",
    "print(math.sin(math.pi/6))\n",
    "print('our sin: ')\n",
    "print(sin(math.pi/6))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51f7a8d7-f13a-4dad-ad55-d7ee8f8c8cc4",
   "metadata": {},
   "source": [
    "#### 2.6.3. default values of function arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "1f54a8c9-3039-48e3-b16e-e48b3d1d173c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "3\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "def f(a=0, b=1): # if some of arguments do not get value, default values are considered for those agruments\n",
    "    return a+b\n",
    "    pass\n",
    "print(f(2, 3)) # 5\n",
    "print(f(2)) # 3\n",
    "print(f())  # 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38c5eea9-dd8f-4650-9e72-d8372b75dc58",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "توجه‌ کنید که متغیرهایی که مقدار پیش‌فرض ندارند باید قبل از دیگر متغیرها بیایند؛ در غیر این صورت خطای سینتکس دریافت می‌کنیم. به طور مثال برنامه زیر بعد از اجرا، خطا می‌دهد.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e995a76-1db4-4f95-ae33-f94a0a0aeca8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(a=0, b):\n",
    "    return a+b\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0cd573f-ae32-4455-9fbe-ddb2e6d2039b",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    کته مهم دیگر در مورد مقادیر پیش‌فرض این است که فقط یک بار مقداردهی و در حافظه ذخیره می‌شوند. سپس در فراخوانی‌های بعدی از آن مقادیر ذخیره‌شده استفاده می‌شود و ممکن است همان مقدار دلخواه را نداشته باشند. برای مثال کد زیر را ببینید:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "677ede4b-2a49-4829-bf63-18eafcb6cdfa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1]\n",
      "[1, 2]\n",
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "def f(a, L=[]):\n",
    "    L.append(a)\n",
    "    return L\n",
    "    pass\n",
    "print(f(1)) # [1]\n",
    "\n",
    "print(f(2)) # [1, 2]\n",
    "\n",
    "print(f(3)) # [1, 2, 3]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a59b1f7-9e2f-499c-8774-82bc04b7d47b",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    همان طور که می‌بینید ‍‍L یک بار محاسبه می‌شود و سپس در فراخوانی‌های بعدی همان L قبلی تغییر می‌کند. برای اجتناب از بروز این مشکل می‌توانیم مقدار پیش‌فرض متغیر را None در نظر بگیریم، سپس درون تابع در صورتی که مقدار None داشت مقدار دلخواه را به آن ا اختصاص دهیم. یعنی تابع بالا را می‌توان به شکل زیر تغییر داد.\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "948ab8a4-a9a9-4f57-a943-0275582d1813",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1]\n",
      "[2]\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "def f(a, L=None):\n",
    "    if L == None:\n",
    "        L = []\n",
    "        L.append(a)\n",
    "        return L\n",
    "        pass\n",
    "    pass\n",
    "print(f(1)) # [1]\n",
    "\n",
    "print(f(2)) # [2]\n",
    "\n",
    "print(f(2,f(1))) # [1, 2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6359853d-8711-48a5-8ec0-6999fc219513",
   "metadata": {},
   "source": [
    "#### 2.6.4. Extra Arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29e29ca6-7d78-4b6e-aefb-392aef2fd964",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    فرض کنید می‌خواهیم تابعی بنویسیم که تعداد ورودی‌هایش مشخص نباشد. به عبارتی بتوان به تعداد دلخواه به آن ورودی داد. برای این کار می‌توانیم بعد از همه ورودی‌های تابع کلمه *args را اضافه کنیم. در این صورت همه ورودی‌های اضافی که دریافت می‌شود، در قالب یک tuple درون *args ذخیره می‌شوند. توجه کنید که اگر ورودی اضافی نداشته باشیم اندازه آن صفر می‌شود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "4fab035e-bec1-4739-ab54-322eaa27f885",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "()\n",
      "(1,)\n",
      "(2, 3)\n"
     ]
    }
   ],
   "source": [
    "def f(a, *args):\n",
    "    return args\n",
    "    pass\n",
    "\n",
    "print(f(2)) # ()\n",
    "\n",
    "print(f(2, 1)) # (1,)\n",
    "\n",
    "print(f(1, 2, 3)) # (2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d03bb41b-3001-47f8-b6c2-f5ee91dd6c64",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    توجه‌ کنید که لزومی ندارد اسم ورودی *args باشد و می‌تواند هر چیز دیگری که با * شروع می‌شود باشد.\n",
    "    <br>\n",
    "نوع دیگری از ورودی‌های اضافه که می‌توان به تابع داد، کلیدواژه‌ها هستند. نحوه استفاده از این ورودی‌ها تقریبا مانند لغت‌نامه است. به این صورت که در ورودی تابع به ازای هر متغیر که می‌خواهیم اضافه کنیم ابتدا اسمشو بعد از یک علامت مساوی، مقدارش را می‌نویسیم. در نهایت تمام این متغیرها در قالب یک لغت‌نامه در **kwargs که باید جزء ورودی‌های تابع باشد ریخته می‌شوند.\n",
    "    <br>\n",
    "برای مثال در زیر تابعی تعریف کرده‌ایم که ابتدا args را می‌گیرد و سپس kwargs و آن‌ها را چاپ می‌کند.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a21383ae-8648-4607-af1f-890484f9e191",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "()\n",
      "{'a': 2}\n",
      "(1,)\n",
      "{'a': 2}\n"
     ]
    }
   ],
   "source": [
    "def f(*args, **kwargs):\n",
    "    print(args)\n",
    "    print(kwargs)\n",
    "    pass\n",
    "f(a=2) # ()\n",
    "       # {'a': 2}\n",
    "\n",
    "f(1, a=2) # (1,)\n",
    "          # {'a': 2}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "8da37dc3-e7f7-444d-ba2e-afd6ab4cccbb",
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "positional argument follows keyword argument (Temp/ipykernel_21624/755564894.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"C:\\Users\\mrzgh\\AppData\\Local\\Temp/ipykernel_21624/755564894.py\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    f(1, a=2, 2)\u001b[0m\n\u001b[1;37m               ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m positional argument follows keyword argument\n"
     ]
    }
   ],
   "source": [
    "f(1, a=2, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42e15c69-e578-4c68-8bd3-16aaf43a5cd6",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    همان طور که می‌بینید اگر **kwargs بعد از ‍‍*args تعریف شود، حتما باید تمام ورودی‌های عادی ابتدا وارد شوند و در غیر این صورت مانند مثال آخر خطای سینتکسی دریافت خواهیم‌ کرد.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d407e57b-5444-4c31-b27e-8cf24784f140",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ali is 21 years old\n",
      "mamadreza is 18 years old\n",
      "mahdi is 22 years old\n"
     ]
    }
   ],
   "source": [
    "def printUsers(**users):\n",
    "    for name,age in users.items():\n",
    "        print(f\"{name} is {age} years old\")\n",
    "        pass\n",
    "    pass\n",
    "printUsers(ali=21, mamadreza=18, mahdi=22)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "effb5716-1e17-40e7-99fe-0162d0a7258c",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "نام عضوی که لغت‌نامه درون آن ریخته می‌شود مانند *args مهم نیست. فقط باید با ** شروع شود. اما استاندارد توابع پایتون این است که این دو را به همین صورت نام‌گذاری کنیم.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fde4cf25-4f7d-409d-a19e-b51c21900dff",
   "metadata": {},
   "source": [
    "#### 2.6.5. Unpacking"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6084916a-e572-414f-84b3-87dbd36911c6",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    فرض کنید لیستی از مقادیر مختلف دارید که می‌خواهید تک تک مقادیر آن را به یک تابع بدهید. به طور کلی با استفاده از کاراکتر * می‌توان یک لیست یا یک چندتایی یا ... را از حالت بسته‌بندی خارج کرد.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "16470113-b251-461f-b0af-2a3c7ab84f6e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n",
      "1 2 3\n",
      "a b c\n"
     ]
    }
   ],
   "source": [
    "print(*[1, 2, 3]) # 1 2 3\n",
    "\n",
    "print(*(1, 2, 3)) # 1 2 3\n",
    "\n",
    "print(*{'a': 1, 'b': 2, 'c': 3}) # a b c\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8a02eb6-4cf1-4b5c-ad7b-53e9cc5bc800",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    استفاده از کاراکتر * می‌توان مقادیر یک لیست را با فاصله در یک خط چاپ کرد. همین‌طور با توجه به خط پنجم اگر از * برای باز کردن لغت‌نامه استفاده کنیم، کلیدهای آن در نظر گرفته می‌شود. اگر بخواهیم یک لغت‌نامه را به صورت kwargs به یک تابع بدهیم کافی است از کاراکتر ** به جای * استفاده کنیم. به مثال‌های زیر توجه کنید:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8dba633-10b9-4db6-b259-295edf7a8bbb",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    <b> مثال 1</b> <br>\n",
    "فرض کنید تابعی به‌نام mean وجود دارد که به تعداد دلخواه ورودی گرفته و میانگین آن‌ها را خروجی ‌می‌دهد. لیستی از اعداد وجود دارد که می‌خواهیم آن‌‌ها را به mean بدهیم. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "4d83076b-b899-4aff-ab5e-9d1b56e82586",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.0\n"
     ]
    }
   ],
   "source": [
    "def mean(*numbers):\n",
    "    return sum(numbers)/len(numbers)\n",
    "    pass\n",
    "data = [1, 2, 3, 4, 5]\n",
    "print(mean(*data))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a67f393b-d120-4aca-a85e-4cd120decb66",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    <b> مثال 2 </b> <br>\n",
    "    این بار فرض کنید تابعی به‌نام people وجود دارد ورودی‌هایی از نوع kwargs گرفته و تمامی آن‌ها را با یک قالب مشخص چاپ می‌کند یک لغت‌نامه وجود دارد که می‌خواهیم مقادیر آن‌ را به people بدهیم.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "a9c6e1ba-5df0-4e5f-a015-8818497b23a2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mohamad is a engineer\n",
      "samad is a worker\n"
     ]
    }
   ],
   "source": [
    "# in this, first dict \"data\" sperate, then passes to function, then use it as dict \"people\"\n",
    "def people(**people):\n",
    "    for name, job in people.items():\n",
    "        print(f'{name} is a {job}')\n",
    "        pass\n",
    "    pass\n",
    "data = {'mohamad': 'engineer', 'samad': 'worker'}\n",
    "people(**data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "68ea589f-801f-4b91-8a50-d9768ed6faed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mohamad is a engineer\n",
      "samad is a worker\n"
     ]
    }
   ],
   "source": [
    "# in this, data passes in type \"dict\"\n",
    "def people(people):\n",
    "    for name, job in people.items():\n",
    "        print(f'{name} is a {job}')\n",
    "\n",
    "data = {'mohamad': 'engineer', 'samad': 'worker'}\n",
    "people(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7681d180-4be3-4183-9fb0-22084a42329c",
   "metadata": {},
   "source": [
    "\n",
    "#### 2.6.6. lambda functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0560db20-8cef-4e40-ad2f-de008ce07de1",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "گاهی اوقات می‌خواهیم یک شی ساده قابل فراخوانی برای پاس دادن به تابع بدون ایجاد سرباری که def ایجاد می‌کنند بسازیم. در این مواقع به توابع ناشناس (lambda function) نیاز پیدا می‌کنیم. توابع ناشناس توابعی کوچکی هستند که می‌توانند هر تعداد ورودی (arguments) داشته باشند ولی تنها یک عبارت (expression) را خروجی می‌دهند. البته می‌توان چندین عبارت را در قالب یک چندتایی یا لیست خروجی داد. <br>\n",
    "    این توابع معمولا یکبار مصرف هستند که باعث کوتاه‌تر شدن کد می‌شوند البته باید توجه داشت که استفاده بیش‌از حد از توابع ناشناس باعث ابهام در کد می‌شود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7337159-5dc9-4114-a420-eb298ca15e34",
   "metadata": {},
   "source": [
    "                                                              lambda arguments : expression\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a6c762c-c40b-4199-9c4d-6c05f09429c6",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    می‌توان بدون نام‌گذاری این توابع از آن‌ها استفاده نمود به همین خاطر به انها توابع ناشناس می گوییم. البته مانند توابع ساده خود پایتون می‌توان توابع ناشناس را درون یک متغیر ریخته که صدا زدن آن متغیر همانند صدا زدن تابع ناشناس می‌باشد. توجه داشته باشید همان‌طور که گفتیم این تابع می‌تواند چندین ورودی داشته باشد.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "f1954f79-a6d6-4249-bea2-1ea2d04cb454",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "4\n",
      "19.0\n",
      "[19.0, 20]\n"
     ]
    }
   ],
   "source": [
    "print((lambda x: x * x)(2)) # 4\n",
    "power_two = lambda x: x * x\n",
    "print(power_two(2)) # 4\n",
    "\n",
    "\n",
    "average = lambda a, b: (a + b) / 2\n",
    "print(average(20, 18)) # 19.0\n",
    "\n",
    "statistic = lambda a, b: [(a + b) / 2, max(a, b)]\n",
    "print(statistic(20, 18)) # [19.0, 20]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9168dc57-6c6e-4975-9ff4-b6271210fe77",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    رایج‌ترین استفاده از تابع‌های لامبدا در کدهایی است که نیازمند توابع یک‌خطی ساده‌ای هستند و نوشتن یک تابع معمولی کامل، زیاده کاری محسوب می‌شود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2e774034-41d4-4b1d-b166-59f03c3ab991",
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist = [(1,3),(4,5),(2,10),(9,6)]\n",
    "\n",
    "mylist.sort()\n",
    "print(mylist) # [(1, 3), (2, 10), (4, 5), (9, 6)]\n",
    "\n",
    "\n",
    "mylist.sort(key = lambda x: x[-1])\n",
    "print(mylist)  # [(1, 3), (4, 5), (9, 6), (2, 10)]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aaf9be8a-db66-4d93-81ee-b4a9b902d039",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    قدرت lambda زمانی بهتر نشان داده می‌شود که از آنها به عنوان توابع ناشناس در درون توابع دیگر استفاده کنید.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "2f727168-108e-4eb9-b7fd-091bdf0b696a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22\n",
      "33\n"
     ]
    }
   ],
   "source": [
    "def myfunc(n):\n",
    "    return lambda a : a * n\n",
    "\n",
    "mydoubler = myfunc(2)\n",
    "mytripler = myfunc(3)\n",
    "\n",
    "print(mydoubler(11)) # 22\n",
    "print(mytripler(11)) # 33"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1dc165cf-1bf4-40f2-9442-fc6a4cfaaeae",
   "metadata": {},
   "source": [
    "#### 2.6.7. Generators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa123beb-2837-40e1-b0a5-838365832b9e",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    یکی از پیمایش‌شونده‌هایی که به طور عادی در پایتون وجود دارند، تولیدکننده‌ها یا generators هستند. در این نوع متغیرها مانند سایر پیمایش‌شونده‌ها می‌توان به عضو بعدی و یا عضو iiام دسترسی داشت. همچنین این نوع از متغیرها حتما باید خروجی یک تابع باشند. برای این که خروجی تابع از این نوع باشد، باید به جای استفاده از return به منظور خروجی دادن، از yield استفاده‌ کرد. نحوه عملکرد این دستور به‌ این صورت است که در هر زمان مفسر به یکی از این دستورها برسد، آن را به انتهای تولیدکننده اضافه‌ می‌کند و زمانی که به انتهای تابع برسد آن را بر می‌گرداند.\n",
    "    <br>\n",
    "    یکی از دلایل بهتر بودن generator ها نسبت به لیست ها ، حافظه خیلی کمی است که generator ها اشغال می کنند.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "a6fbc3a2-218b-4e5e-b023-5aceca2c199d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "<generator object f at 0x000001F9C25F03C0>\n",
      "[6, 3, 2]\n"
     ]
    }
   ],
   "source": [
    "def f(n):\n",
    "    yield n//1\n",
    "    yield n//2\n",
    "    yield n//3\n",
    "\n",
    "div = f(6)\n",
    "print(type(div))\n",
    "print(div)\n",
    "print(list(div))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "128abc37-72bb-43c4-ba82-ae8008871204",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    ابتدا تابع f یک عدد ورودی گرفته و به ترتیب خارج قسمت آن را بر ۱ و ۲ و ۳ را بر می‌گرداند. همان طور که مشخص است نوع خروجی تابع ما generator می‌باشد.در خط سوم هم div به list تبدیل شده که همان خروجی مورد نظر ما را داده‌ است.\n",
    "<br>\n",
    "با استفاده از تابع زیر هم می‌توانیم range را با استفاده از generator پیاده‌سازی کنیم.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "c3cb82e0-96da-48e5-8535-2482dcc8e0d8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 4 7 \n",
      "[1, 5, 9, 13, 17]\n"
     ]
    }
   ],
   "source": [
    "def myRange(l, r, step=1):\n",
    "    while l < r:\n",
    "        yield l\n",
    "        l += step\n",
    "    return 0\n",
    "    yield 0\n",
    "    pass\n",
    "for i in myRange(1, 10, 3):\n",
    "    print(i, end=' ')\n",
    "    pass\n",
    "print()\n",
    "print(list(myRange(1, 20, 4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3530b2f7-7fff-4b42-ae7b-c4f81143e105",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "دقت کنید که دستور yield 0 به این دلیل که قبل از آن یک return آمده است، هیچوقت اجرا نمی‌شود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19a0d0d5-7d75-4ea8-b27e-f91e998d7d0d",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "---------------------------\n",
    "### 2.7. Decorators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83d99d7b-93ff-4c32-ba67-088c27d34811",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### 2.7.1. Basics"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9fce373-bce5-4821-a517-b22c020bdd8b",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "به طور کلی decorator تابعی است که یک تابع ورودی گرفته و تابعی جدید بر اساس تابع ورودی می‌سازد (که در بین صدا شدن این تابع و تابع اصلی یک سری مدیریت‌ها و آماده سازی‌ها صورت می‌گیرد) و تابع ساخته شده را خروجی می‌دهد\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e0a5bd5-2998-477b-9daf-0b13cb4b8545",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "برای مثال یک decorator تعریف می‌کنیم که چک می‌کند ورودی تابع حتما از جنس int باشد.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0dcfe261-4cd4-45bd-ac37-ad248bd9f4d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "salamsalam\n"
     ]
    },
    {
     "ename": "Exception",
     "evalue": "argument should be int",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mException\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_6160/1198721757.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     12\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     13\u001b[0m \u001b[0mf\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mint_check_decorator\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mf\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 14\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mf\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'salam'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_6160/1198721757.py\u001b[0m in \u001b[0;36mg\u001b[1;34m(x)\u001b[0m\n\u001b[0;32m      2\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mg\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m   \u001b[1;31m# \"x\" is argument of function \"f\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mtype\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m!=\u001b[0m \u001b[0mint\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m             \u001b[1;32mraise\u001b[0m \u001b[0mException\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'argument should be int'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      5\u001b[0m         \u001b[1;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[0mg\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mException\u001b[0m: argument should be int"
     ]
    }
   ],
   "source": [
    "def int_check_decorator(f):\n",
    "    def g(x):   # \"x\" is argument of function \"f\"\n",
    "        if type(x) != int:\n",
    "            raise Exception('argument should be int')\n",
    "        return f(x)\n",
    "    return g\n",
    "\n",
    "def f(a):\n",
    "    return a+a\n",
    "\n",
    "print(f('salam'))\n",
    "\n",
    "f = int_check_decorator(f)\n",
    "print(f('salam'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6568f6a3-a619-4835-8611-9529566f7624",
   "metadata": {
    "tags": []
   },
   "source": [
    "<div style = \"direction:rtl\">\n",
    "در پایتون معمولا decorator با استفاده از @ خوانده می‌شود. به این شکل که بعد از @ اسم decorator می‌آید و در خط بعد تابع مورد نظر تعریف می‌شود. پایتون تابع را به decorator ورودی می‌دهد و جای آن خروجی decorator را می‌گذارد.\n",
    "    <br>\n",
    "    معادل مثال قبل به شکل زیر است.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "2944f7c3-5ec6-48da-af4d-913587551d46",
   "metadata": {},
   "outputs": [
    {
     "ename": "Exception",
     "evalue": "argument should be int",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mException\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_6160/518095355.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     10\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[0ma\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     11\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 12\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mf\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'salam'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_6160/518095355.py\u001b[0m in \u001b[0;36mg\u001b[1;34m(x)\u001b[0m\n\u001b[0;32m      2\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mg\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mtype\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m!=\u001b[0m \u001b[0mint\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m             \u001b[1;32mraise\u001b[0m \u001b[0mException\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'argument should be int'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      5\u001b[0m         \u001b[1;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[0mg\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mException\u001b[0m: argument should be int"
     ]
    }
   ],
   "source": [
    "def int_check_decorator(f):\n",
    "    def g(x):\n",
    "        if type(x) != int:\n",
    "            raise Exception('argument should be int')\n",
    "        return f(x)\n",
    "    return g\n",
    "\n",
    "@int_check_decorator\n",
    "def f(a):\n",
    "    return a+a\n",
    "\n",
    "print(f('salam'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "576b4640-1b23-4b9e-bc46-5c1a9449d0c3",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "مثال دیگر:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6f18ac29-db86-45dd-8af5-8a43e895d708",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n"
     ]
    }
   ],
   "source": [
    "def return_value_for_10(f):\n",
    "    return f(10)\n",
    "\n",
    "@return_value_for_10\n",
    "def f(a):\n",
    "    return a+a\n",
    "\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ac2af8e-8f47-4d18-9261-fd690a54cd4f",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "پایتون تابع بعد decorator را به return_value_for_10 ورودی می‌دهد. این decorator مقدار تابع را برای ورودی 10 حساب کرده و جای f این مقدار را می‌گذارد. پس خروجی کد باید عدد ۲۰ باشد.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f87210c-94c1-4d0f-9e1e-bcd50a97877e",
   "metadata": {},
   "source": [
    "#### 2.7.2. Applications of Decorators "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb75ef90-068e-4333-a494-a447d4297526",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "<h5> 2.7.2.1. کنترل آرگومان‌ها </h5> \n",
    "<br>\n",
    "همان طور که در مثال اول دیدید با استفاده از decorator می‌توان کنترل کرد که آرگومان‌های تابع به چه شکل باشند.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08e89a15-4cb3-4fec-b994-b010b2630be8",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "<h5> 2.7.2.2. شمردن تعداد دفعات صدا شدن تابع </h5>\n",
    "    <br>\n",
    "    یک decorator تعریف می‌کنیم که یک لغت‌نامه از اسم توابع و تعداد دفعات صدا شدن آنها درست ‌می‌کند.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d1aee16b-58ca-43dc-a077-c7b473dbc715",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "f: 3\n",
      "g: 2\n",
      "h: 2\n"
     ]
    }
   ],
   "source": [
    "calls = {}\n",
    "\n",
    "def call_count_decorator(func):\n",
    "\n",
    "    calls[func.__name__] = 0\n",
    "\n",
    "    def ret(*args, **kwargs):\n",
    "        calls[func.__name__] += 1\n",
    "        return func(*args, **kwargs)\n",
    "\n",
    "    return ret\n",
    "\n",
    "@call_count_decorator\n",
    "def f(x):\n",
    "    pass\n",
    "\n",
    "@call_count_decorator\n",
    "def g(x, y):\n",
    "    pass\n",
    "\n",
    "@call_count_decorator\n",
    "def h():\n",
    "    pass\n",
    "\n",
    "f(1)\n",
    "f('a')\n",
    "f('salam')\n",
    "g(1, 2)\n",
    "g(2, 2)\n",
    "h()\n",
    "h()\n",
    "for k, v in calls.items():\n",
    "    print(k + \": \" + str(v))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bcef8a2d-a7b1-46c1-bb1c-da56bbf9973d",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "@call_count_decorator روی جایی که تابع داره تعریف میشه، مثلا تابع f(x) معادل دستور زیره. البته بعد از اینکه تابع f رو تعریف کرده باشین.\n",
    "<br>\n",
    "f = call_count_decorator(f)\n",
    "<br>\n",
    "دستور بالا باعث میشه تابع call_count_decorator با ورودی تابع f صدا زده بشه (به یاد بیارین همه چیز در پایتون یه شی هست حتی توابع) خروجی تابع call_count_decorator تابع ret هست. پس مقدار تابع ret داخل f قرار میگیره. منتهی تابع ret که برای f شخصی سازی شده. پس از این به بعد هر بار که f صدا زده بشه، ret صدا زده میشه.\n",
    "    <br>\n",
    "    پس به طور کلی عبارت هایی که خارج تابع داخل decorator نوشته می شوند ، به ازای هر بار نوشتن @decorator_name   تنها یکبار اجرا می شوند ، نه اینکه به ازای هر بار صدا شدن تابع ورودی decorator انها نیز اجرا شوند.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de6bdd5c-1b6f-4135-9289-a6341fb18a85",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "با استفاده از (*args, **kwargs) می‌توان به هر شکل ورودی گرفت.\n",
    "<br>\n",
    "در obj.__name__ نام آن شی نگه‌داری می‌شود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e9346c8-0183-4d34-81dc-48a03bd899b1",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "<h4> 2.7.3. ورودی دادن به decorator </h4>\n",
    "    <br>\n",
    "    همان طور که اشاره شده برای استفاده از decorator باید آن را بعد از @ نوشت. خود چیزی که بعد از @ نوشته می‌شود هم می‌تواند خروجی یک تابع دیگر(!) باشد. به این روش می‌توان decoratorهایی ساخت که آرگومان ورودی می‌گیرند.\n",
    "<br>\n",
    "برای مثال تابع زیر یک decorator تولید می‌کند که با توجه به پارامتر‌های تابع سازنده تشکیل می‌شود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "06847400-d58f-4c8a-a6f6-cd4797382230",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "f:\n",
      "Argument must be int\n",
      "2\n",
      "g:\n",
      "salam khoobi?\n",
      "Argument must be str\n",
      "form2:\n",
      "Argument must be int\n",
      "form3:\n",
      "Argument must be int\n"
     ]
    }
   ],
   "source": [
    "def decorator_builder(check_class):  # \"check_class\" is the input of decorator\n",
    "    def type_checker(func):  # \"func\" is the function that decorator is used for\n",
    "        def ret(x):  # \"x\" is the input of \"func\".\n",
    "            if not isinstance(x, check_class):\n",
    "                return \"Argument must be \" + check_class.__name__\n",
    "            else:\n",
    "                return func(x)\n",
    "        return ret\n",
    "    return type_checker\n",
    "\n",
    "@decorator_builder(int)\n",
    "def f(x):\n",
    "    return 2**x\n",
    "\n",
    "@decorator_builder(type(\"salam\"))\n",
    "def g(x):\n",
    "    return x + \" khoobi?\"\n",
    "\n",
    "print('f:')\n",
    "print(f('salam'))\n",
    "print(f(1))\n",
    "\n",
    "print('g:')\n",
    "print(g('salam'))\n",
    "print(g(1))\n",
    "\n",
    "#در واقع استفاده از این دکوراتور بدون @ مطابق زیر است\n",
    "print(\"form2:\")\n",
    "decorator = decorator_builder(int)\n",
    "f = decorator(f)\n",
    "print(f(\"salam\"))\n",
    "print(\"form3:\")\n",
    "#و یا به شکل زیر\n",
    "print(decorator_builder(int)(f)(\"salam\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9854c60a-b3e4-4286-8d82-d363cf71e562",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "خروجی تابع decorator_builder یک decorator است که جنس آرگومان ورودی تابع را کنترل می‌کند. وقتی بعد از @ این تابع استفاده می‌شود این تابع براساس ورودی داده‌شده decorator مورد نظر را می‌سازد و خروجی می‌دهد و انگار آن را جلوی @ نوشته‌ایم.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5123b040-ab19-4fac-9501-d8268ecb7530",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "<h4> 2.7.4. کلاس‌ها به عنوان decorator </h4>\n",
    "<br>\n",
    "کلاس و یا هر شی صدا شونده‌ای می‌تواند یک decorator باشد.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e8b32f58-845f-4244-b58d-f6a206ea23fb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "salam\n",
      "hello\n"
     ]
    }
   ],
   "source": [
    "class decorator:\n",
    "\n",
    "    def __init__(self, msg):\n",
    "        self.msg = msg\n",
    "\n",
    "    def __call__(self, func):\n",
    "        def ret():\n",
    "            print(self.msg)\n",
    "            return func()\n",
    "        return ret\n",
    "\n",
    "dec = decorator('salam')\n",
    "\n",
    "@dec\n",
    "def f():\n",
    "    pass\n",
    "\n",
    "@decorator('hello')\n",
    "def g():\n",
    "    pass\n",
    "\n",
    "f()\n",
    "g()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "becf7ee7-f78b-4a23-b62d-343b93c61e1b",
   "metadata": {
    "tags": []
   },
   "source": [
    "---------------------------------\n",
    "### 2.8. Data Structure"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "773e6dd4",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### 2.8.1. Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0508697-e6b0-408e-86f4-015db1a4d229",
   "metadata": {},
   "source": [
    "list is a data structure that keeps a list of any type of objects. <br>\n",
    "- list is a mutable object. <br>\n",
    "- list is a iterable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "7bc48956-f0a4-4371-a9a7-6076aa2bfa76",
   "metadata": {},
   "outputs": [],
   "source": [
    "lucky_numbers = [4, 8, \"fifteen\", 16, 23, 42.0]  # for making a list, use []\n",
    "\n",
    "zeros = [0]*100  # makes a list of lenght 100 with all zero.\n",
    "\n",
    "salamlist = list(\"salam\") # list() function is used for convertion to list\n",
    "ls = list((20, 30, 40))\n",
    "\n",
    "\n",
    "lucky_numbersC = lucky_numbers[:]    # copying a list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e85cbea5-3b9e-453a-a8c9-ce70f2885980",
   "metadata": {},
   "source": [
    "- List passes by-reference."
   ]
  },
  {
   "cell_type": "raw",
   "id": "ca72fa32-a5c1-404f-a2fc-8dffe827da52",
   "metadata": {},
   "source": [
    ">>> main = [1, 2, 3]\n",
    ">>> ref = main\n",
    ">>> ref\n",
    "[1, 2, 3]\n",
    ">>> main[0] = 10\n",
    ">>> ref\n",
    "[10, 2, 3]\n",
    ">>> ref[0] = 1\n",
    ">>> main\n",
    "[1, 2, 3]\n",
    ">>>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "b08ac7e4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "42.0\n",
      "['fifteen', 16, 23, 42.0]\n",
      "['fifteen', 16]\n",
      "[4, 8, 'fifteen', 16, 23, 42.0]\n",
      "90\n",
      "['eighteen', 12.5, 1]\n",
      "6\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "### list Indexing\n",
    "print(lucky_numbers[1])  \n",
    "print(lucky_numbers[-1])   #  = lucky_numbers[len(lucky_numbers) - 1]\n",
    "print(lucky_numbers[2:])  \n",
    "print(lucky_numbers[2:4])\n",
    "print(lucky_numbers[:])\n",
    "\n",
    "### changing of list\n",
    "lucky_numbers[0] = 90\n",
    "print(lucky_numbers[0])\n",
    "lucky_numbers[2:5] = [\"eighteen\", 12.5, 1]\n",
    "print(lucky_numbers[2:5])\n",
    "\n",
    "\n",
    "print(len(lucky_numbers))  \n",
    "\n",
    "\n",
    "x = range(0, 10, 1)  # \"range(start, end, step)\" is a function which creates a integer list from \"start\" to \"end\" (except end) with step of \"step\"\n",
    "print(x[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2bc96cf8-e9ee-4b86-8302-a7d342d16e23",
   "metadata": {},
   "source": [
    "##### 2.8.1.1. List Functions (Very Important!)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de8d4ae0-420f-4281-9968-47b78902834c",
   "metadata": {},
   "source": [
    "- by \"del\" and \"append()\", we can construct a stack or a queue.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "de3235e6-2a99-457a-9bf4-8be5e73db723",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Oscar', 'KevinSmith', 4, '1, 5', 'Angela']\n",
      "0\n",
      "1\n",
      "['1, 5', 'Angela', 'KevinSmith']\n",
      "['1, 5', 'Angela', 'KevinSmith']\n",
      "['KevinSmith', 'Angela', '1, 5']\n",
      "KevinSmith/Angela/1, 5\n"
     ]
    }
   ],
   "source": [
    "z = 4\n",
    "friends = []\n",
    "friends.extend([\"Oscar\"])  # .extend(iterable)    insert iterable at the end of the list\n",
    "friends.extend([z, \"1, 5\"])\n",
    "friends.extend([\"Angela\"])\n",
    "friends.insert(1, \"KevinSmith\") # inserts the value in the place with index 1\n",
    "print( friends ) \n",
    "\n",
    "print( friends.index(\"Oscar\") )  # list.index(x, startIndex, endIndex)\n",
    "print( friends.count(\"Angela\") )\n",
    "\n",
    "friends.remove(4) # .remove(value) remove element with the value\n",
    "del friends[0]  # remove value of index 0\n",
    "\n",
    "\n",
    "# list.sort(key=None, reverse=False) - key and reverse are optional - all values of list must have same type\n",
    "friends.sort()  \n",
    "print(friends)\n",
    "def getLength(a):\n",
    "    return len(a)\n",
    "    pass\n",
    "friends.sort(key=getLength) # sorts based on lenght\n",
    "print(friends)\n",
    "friends.sort(reverse=True) \n",
    "print(friends)\n",
    "\n",
    "wholestr = '/'.join(friends) # concatenate all values of friends list with / and returns a string. all values of list must be string\n",
    "print(wholestr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0dbf6361-694c-4af6-a079-8ec6bd2015ad",
   "metadata": {},
   "source": [
    "--------------------------------\n",
    "- __\"del\" instruction__"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b160e02b-ff33-4042-8bdf-80210a23eeac",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "یکی از کاربرد های دستور del حذف عضو از لیست است. تفاوت این دستور با تابع list.pop() در این است که می‌توان با این دستور بخشی از یک لیست را حذف کرد.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "61666c64-f435-44ec-b8f7-a11b03a9fd46",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['rafte', 'key', 'barmigarde?']\n",
      "['barmigarde?']\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "a = ['ali', 'rafte', 'key', 'barmigarde?']\n",
    "del a[0]\n",
    "print(a) # ['rafte', 'key', 'barmigarde?']\n",
    "\n",
    "del a[0:2]\n",
    "print(a) # ['barmigarde?']\n",
    "\n",
    "del a[:]\n",
    "print(a) # []"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4afee7d5-893b-4590-8eff-48c388978daf",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    دستور del، می‌تواند متغیرها، توابع و کلاس‌های ساخته‌شده و ... را نیز به طور کلی حذف کند\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "94956e7f-aea1-49ae-abc5-e085537e76ce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "salam\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'name' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_21624/2248200337.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;32mdel\u001b[0m \u001b[0mname\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'name' is not defined"
     ]
    }
   ],
   "source": [
    "name = \"salam\"\n",
    "print(name)\n",
    "del name\n",
    "print(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e2f9caa-e0f1-48d7-b7db-aae49370928f",
   "metadata": {},
   "source": [
    "------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c0e541f-f568-461e-b0cb-fb4f1e3cc874",
   "metadata": {},
   "source": [
    "##### 2.8.1.2. list Iteration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "21ca6267-1d57-43e8-ad77-22e4936b1012",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ali\n",
      "1\n",
      "2\n",
      "3\n",
      "chetor\n"
     ]
    }
   ],
   "source": [
    "myList = ['ali', 1, 2, 3, 'chetor']\n",
    "for it in myList:\n",
    "    print(it)\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb6c1fb5-15c4-4550-ac20-87ead9b3ca79",
   "metadata": {},
   "source": [
    "###### 2.8.1.2.1. \"enumerate\" function"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0d182f0-485e-4484-aa69-0c276da34be7",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    با این تابع می‌توان اندیس یک شیء که پیمایش می‌شود را نیز هم‌زمان با خود شیء در دسترس داشت.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "f7a7d68f-09aa-4eee-9d12-a093db2fe57c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the 1th object in myList is 0!\n",
      "the 2th object in myList is 1!\n",
      "the 3th object in myList is 2!\n",
      "the 4th object in myList is 3!\n"
     ]
    }
   ],
   "source": [
    "myList = [0, 1, 2, 3]\n",
    "for i, it in enumerate(myList):\n",
    "    print(\"the {0}th object in myList is {1}!\".format(i+1, it))\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40e1b354-b7eb-4162-b198-05d1cafac36a",
   "metadata": {},
   "source": [
    "###### 2.8.1.2.2. \"zip\" function"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97c95eef-8798-448b-a96a-a39d64ccfdc4",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "با استفاده از این تابع می‌توان چند لیست را به طور هم‌زمان پیمود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "52547987-ce29-4dab-8979-f75085625a6b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1th alphabet or I in greece is a\n",
      "2th alphabet or II in greece is b\n",
      "3th alphabet or III in greece is c\n",
      "4th alphabet or IV in greece is d\n"
     ]
    }
   ],
   "source": [
    "listA = [1, 2, 3, 4]\n",
    "listB = ['a', 'b', 'c', 'd']\n",
    "listC = ['I', 'II', 'III', 'IV']\n",
    "for a, b, c in zip(listA, listB, listC):\n",
    "    print(\"{0}th alphabet or {1} in greece is {2}\".format(a, c, b))\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc13f4e7-8b99-468a-9d8a-b2f1f0921fa8",
   "metadata": {},
   "source": [
    "###### 2.8.1.2.3. \"filter\" function"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af629595-91dc-450d-9255-16f69b71d34b",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "این تابع به عنوان آرگومان به ترتیب یک تابع (فرض کنید f) و یک شیء قابل پیمایش (فرض کنید iter) را می‌گیرد. تابع f را برای همه‌ی عناصر شیء iter صدا می‌زند. اگر خروجی False بود آن عنصر را حذف می‌کند. نهایتا نتیجه را در قالب یک پیمایشگر بر‌می‌گرداند.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa8f8c95-7e7b-40f0-9d8d-54153a839308",
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    return True if x%2 == 0 else False\n",
    "    pass\n",
    "\n",
    "ls = [1, 2, 4, 3, 6, 4]\n",
    "print(filter(f, ls))\n",
    "for x in filter(f, ls):\n",
    "    print(x, end=' ')\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e70aa88-9252-4254-8fb3-71c92bc57a56",
   "metadata": {},
   "source": [
    "###### 2.8.1.2.4. \"map\" function"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12be2f06-3c5e-46ed-9bf4-b84ca0d02d6a",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    ساختار این تابع همانند filter است ولی عملکرد آن‌ها با هم متفاوت است. به این صورت که تابع f را برای همه‌ی عناصر شیء iter صدا می‌زند و خروجی آن را جایگزین عنصر کنونی iter می‌کند. نهایتا نتیجه را در قالب یک پیمایشگر بر‌می‌گرداند.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4c3e393a-c2a2-4da1-a4c3-f292f197c0ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    return int(x)\n",
    "\n",
    "ls = [2, '4', False, 3.14]\n",
    "print(map(f, ls))\n",
    "for x in map(f, ls):\n",
    "    print(x, end=' ')\n",
    "    pass\n",
    "for x in map(int, ls):\n",
    "    print(x, end=' ')\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0d0ac2c-c7d0-4158-9cbe-7424e3b92472",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    در مثال بالا int را به عنوان آرگومان به map دادیم. ولی آن‌ را از قبل تعریف نکرده‌ بودیم. ولی همان‌طور که در درس‌های گذشته دیدیم، int یک ورودی می‌گیرد و آن را به عدد صحیح تبدیل می‌کند. در نتیجه می‌توان با استفاده از یک خط در یک خط به تعداد دلخواه ورودی گرفته و آن‌ها را با استفاده از تابع map به روش‌های گوناگونی تغییر داد. فرض کنید می‌خواهید در یک خط تعداد نامشخصی عدد را از کاربر دریافت کرده و جمع آن‌ها را بدست آورید :\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "47c88420-0b30-41d1-be98-d0e2a054f13f",
   "metadata": {},
   "outputs": [],
   "source": [
    "number = map(int, input().split())\n",
    "print(number)\n",
    "\n",
    "print(sum(number))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b75ce8c-c851-429c-82c9-07b26447ca78",
   "metadata": {},
   "source": [
    "###### 2.8.1.2.5. \"sum\" function"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0d24925-cf95-4d28-8f38-21cc83d231ef",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    با استفاده از تابع sum می‌توان حاصل جمع مقادیر درون یک شیء قابل پیمایش را بدست آورد. دقت کنید که مقادیر درون شیء موردنظر باید حتما از نوع عددی باشند. به مثال زیر دقت کنید :\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "975344b6-c591-4292-80e0-344fa9fc8546",
   "metadata": {},
   "outputs": [],
   "source": [
    "ls = [1, 2, 3, 4]\n",
    "print(sum(ls))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "07bd74ab-e398-4977-9247-50e8579a5719",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_4072/1255623871.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mls\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;34m'a'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'b'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'c'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'd'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0msum\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mls\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "ls = ['a', 'b', 'c', 'd']\n",
    "sum(ls)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8e01047-78eb-4fc8-8a76-e5afae2b1faa",
   "metadata": {},
   "source": [
    "##### 2.8.1.3. list comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "0888fe2e-ab4e-455b-b8b2-9af08ce4d314",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
     ]
    }
   ],
   "source": [
    "sq = [x*x for x in range(10)]\n",
    "print(sq)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01f6c4df-ed21-45c7-ae68-a350dfefc9e0",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    یک معرف‌ لیست، شامل یک [] می‌باشد که در آن عبارتی نوشته شده است و به دنبال آن for می‌آید. پس از عبارت for می‌تواند تعدادی دستور کنترلی بیاید. در نهایت لیست بر اساس عبارت اول ساخته می‌شود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cde76728-29a4-466e-be85-15926d2994b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "print([0 for x in range(5)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "27e42cb6-ee11-4ed8-ab99-6a0d2c81df99",
   "metadata": {},
   "outputs": [],
   "source": [
    "print([str(x)+y for x in [1, 2, 3] for y in ['A', 'B']])\n",
    "['1A', '1B', '2A', '2B', '3A', '3B']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ea4ff1b7-da5a-4fdb-ad2c-f5785ab0e031",
   "metadata": {},
   "outputs": [],
   "source": [
    "print([(x, y) for x in [1, 2, 3] for y in [1, 2, 3] if x != y])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "2227fa13-7143-4626-8d51-17d8a85ebc02",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 53, 122]\n",
      "[100, 16, 2809, 14884, 0]\n"
     ]
    }
   ],
   "source": [
    "data = [10, -4, 53, 122, 0]\n",
    "print([x for x in data if x > 0])\n",
    "print([x*x for x in data])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "ea19f414-b302-4a6b-bd87-d64c178b48bf",
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (Temp/ipykernel_21624/225557189.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"C:\\Users\\mrzgh\\AppData\\Local\\Temp/ipykernel_21624/225557189.py\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    print([x*x, x for x in data])\u001b[0m\n\u001b[1;37m                  ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "print([x*x, x for x in data])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0522f4ba-ff6e-4b92-8763-fff62fe7388a",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    دقت کنید که فقط می‌توانید یک عبارت قبل اولین ‍‍for بنویسید تا لیست از روی آن ساخته شود، برای همین آخرین دستور در مثال بالا خطای نحوی می‌دهد.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f8a9560-795d-4746-9728-c9eb9a2ed061",
   "metadata": {},
   "source": [
    "##### 2.8.1.4. nested list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04b234c3-9479-4b1c-aae9-d12e0bef797e",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    همانطور که گفته شد لیست می‌تواند شامل شی‌هایی از هر جنس باشد. به طور خاص می‌توان لیستی از لیست‌ها ساخت. این یک روش به‌صرفه برای پیاده‌سازی آرایه‌های چندبعدی‌ است.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "6db26cba-cdd9-4d5d-bf1a-55ab6d9d0225",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 \n",
      "4 5 6 \n",
      "7 8 9 \n"
     ]
    }
   ],
   "source": [
    "matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "for i in range(3):\n",
    "    for j in range(3):\n",
    "        print(matrix[i][j], end=' ')\n",
    "        pass\n",
    "    print()\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4326acce-188f-44e5-98ad-00d6fdc1ccb9",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    حال فرض کنید می‌خواهید یک لیست دارای nn سطر و mm ستون بسازید که هرکدام از خانه‌های آن صفر باشد. چنین چیزی را به چند روش می‌توان انجام داد که دو روش از آن‌ها در زیر آمده‌اند. در روش اول از عملگر * و در روش دوم از معرف لیست استفاده شده است.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dfa410e6-f554-416e-b7b6-3a448d3dbfe1",
   "metadata": {},
   "outputs": [],
   "source": [
    "zeros = [[0]*m]*n    # first way"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8826a3a2-3f06-4330-8834-42bba6d126fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "zeros = [[0 for c in range(m)] for r in range(n)]    # second way"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f1f2b33-03a9-4fc4-9b15-f3904ddd8bce",
   "metadata": {},
   "source": [
    "----------------------\n",
    "#### 2.8.2. Tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a1f5b90-7229-41cf-8a08-1e6228e982b7",
   "metadata": {},
   "source": [
    "is a data structure that keeps some objects of any type (like list).\n",
    "- Tuple is immutable(difference between list and tuple).\n",
    "- Tuple is a iterable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9e62b224-23ba-44c8-8251-20c976d5fd93",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('ali', 123, 2.5)\n",
      "<class 'tuple'>\n",
      "(2, 4)\n"
     ]
    }
   ],
   "source": [
    "# definition of tuple\n",
    "t = (\"ali\", 123, 2.5)\n",
    "print(t)\n",
    "print(type (t))\n",
    "\n",
    "t = tuple([2, 4])\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a9ecffd0-40c7-461d-8504-c3b1324831f8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "<class 'tuple'>\n",
      "<class 'int'>\n",
      "1\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "t = ()\n",
    "print(len(t)) # 0\n",
    "print(type(t)) # class 'tuple'\n",
    "\n",
    "\n",
    "t = (1)\n",
    "print(type(t)) # class 'int'\n",
    "\n",
    "\n",
    "t = 1,\n",
    "print(len(t))  # 1\n",
    "print(type(t)) # class 'tuple'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c05b39c3-1f22-42e1-a090-9f4270b84a9d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n",
      "30\n",
      "20\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "a, b, c = 10, 20, 30\n",
    "print(a) # 10\n",
    "print(b) # 20\n",
    "print(c) # 30\n",
    "\n",
    "\n",
    "a, b = b, a\n",
    "print(a) # 20\n",
    "print(b) #10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0e73a185-4b17-4a5b-8d3e-532f5b642e5d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ali\n",
      "('ali', 123)\n",
      "ali\n",
      "123\n",
      "2.5\n"
     ]
    }
   ],
   "source": [
    "# tuple indexing is like list, etc. \n",
    "t = (\"ali\", 123, 2.5)\n",
    "print(t[0])\n",
    "print(t[0:2])\n",
    "\n",
    "for it in t:\n",
    "    print(it)\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3874956e-08e8-4a8f-9ad7-dd5ff30ec2e6",
   "metadata": {},
   "source": [
    "- one of applications of tuple is returning several value from function, because of being immutable, it is better to use tuple instead of list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "73fe7d60-15bf-4665-b632-44d79bbd7690",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, '12']\n",
      "[10, 2, '12']\n"
     ]
    }
   ],
   "source": [
    "# returning by list\n",
    "myList = [1, 2]\n",
    "def f():\n",
    "    return myList\n",
    "    pass\n",
    "a = f()\n",
    "a.append(\"12\")\n",
    "print(myList) # [1, 2, '12']\n",
    "a[0] = 10\n",
    "print(myList) # [10, 2, '12']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e0a4c62b-a878-4ba8-9012-31268a84ee78",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2)\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_4072/3508472679.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[0ma\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mf\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# (1, 2)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 7\u001b[1;33m \u001b[0ma\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m10\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "# returning by tuple\n",
    "myTuple = (1, 2)\n",
    "def f():\n",
    "    return myTuple\n",
    "a = f()\n",
    "print(a) # (1, 2)\n",
    "a[0] = 10 # because tuple is immutable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f368bc08-b767-4490-9fac-1260dbf67aed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2)\n"
     ]
    }
   ],
   "source": [
    "a = 3, 4\n",
    "print(myTuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8453e9db-052d-4888-b3bf-ced780fad283",
   "metadata": {},
   "source": [
    "---------------------------\n",
    "#### 2.8.3. Set"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e5975e5-dcc2-4c3a-915a-ae02b86a89b9",
   "metadata": {},
   "source": [
    "Set in pyhton is like set in math.\n",
    "- mutable\n",
    "- Set don't have order and repeatance (difference between list and set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "910998f0-34bd-4347-8cf8-a4830ccbd35a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'set'>\n",
      "{1, 2, 3}\n",
      "3\n",
      "<class 'set'>\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "print(type(set())) # <class 'set'>\n",
    "\n",
    "st = {2, 3, 1}\n",
    "print(st) # {1, 2, 3}\n",
    "print(len(st)) # 3\n",
    "print(type(st)) # <class 'set'>\n",
    "\n",
    "st = {}   # for creating null set, we must use set() \n",
    "print(type(st)) # <class 'dict'>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "e04ac4e7-3b84-48a3-b8bc-5687abad4b58",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'ali', 'mohamadreza', 'amir'}\n"
     ]
    }
   ],
   "source": [
    "# adding to Set\n",
    "names = set()\n",
    "names.add('ali')\n",
    "names.add('mohamadreza')\n",
    "names.add('amir')\n",
    "names.add('amir') # if a value exists in the set, it won't be added again.\n",
    "print(names)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4152d4ec-141c-4a34-b92e-bbaee721be10",
   "metadata": {},
   "source": [
    "##### 2.8.3.1. removing a value from set"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07ca8508-0724-4ab2-9f86-af791e713c07",
   "metadata": {},
   "source": [
    "Set doesn't have order, so we cannot remove from the list by index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "6916e53c-5717-4630-9221-6b2a1b2d8c99",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{3}\n"
     ]
    }
   ],
   "source": [
    "a = {1, 2, 3}\n",
    "a.remove(1)\n",
    "a.discard(2)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71868d0c-9075-4920-b6f3-fa9bf284e77b",
   "metadata": {},
   "source": [
    "- difference between remove() and discard () is that if the value don't exist in the set, discard(the value) do not err but remove(the value) err."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "9a3c941c-8d1f-4d3c-a4bd-0dc129ad9a70",
   "metadata": {},
   "outputs": [],
   "source": [
    "a.discard(4) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "1049097a-2adf-487d-92fb-96d97d523842",
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "4",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_4072/1218533014.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0ma\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m: 4"
     ]
    }
   ],
   "source": [
    "a.remove(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "2ee0ff60-81de-473a-8805-abcb4c6828db",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{2, 3}\n",
      "{2, 3}\n",
      "{1, 2, 3, 4}\n"
     ]
    }
   ],
   "source": [
    "a = {1, 2, 3}\n",
    "b = {3, 2, 4}\n",
    "print(a.intersection(b)) # اشتراک دو مجموعه\n",
    "print(b.intersection(a))\n",
    "\n",
    "print(b.union(a)) # اجتماع دو مجموعه"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "113a391a-0f83-4dec-b5f3-7b21f48d4ba3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1}\n",
      "{1, 4}\n"
     ]
    }
   ],
   "source": [
    "a = {1, 2, 3}\n",
    "b = {3, 2, 4}\n",
    "print(a.difference(b)) # {1}     # تفاضل دو مجموعه\n",
    "\n",
    "print(b.symmetric_difference(a)) # {1, 4}    # تفاضل متقارن دو مجموعه"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "6ef51966-169d-4078-aa28-f223421e93d5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'s', 'l'}\n"
     ]
    }
   ],
   "source": [
    "# Set Comprehension\n",
    "a = set(\"salam\")\n",
    "b = set(\"varam\")\n",
    "print({x for x in a if x not in b})   # like list comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c26114e1-f5a3-409e-b0cd-984f51145e3b",
   "metadata": {},
   "source": [
    "-------------------------\n",
    "#### 2.8.4. Dict"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e0fb5fc-3108-4231-a05c-f764e3a3d0fd",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    یک داده‌ساختار تغییر‌پذیر در پایتون است. لغت‌نامه را می‌توان لیستی تعریف کرد که اندیس‌های آن به جای این که عدد باشند، اشیای تغییر‌ناپذیر هستند. مانند رشته‌ها، اعداد و چندتایی‌هایی که شامل اشیای تغییرپذیر نمی‌شوند. لغت‌نامه از جفت‌هایی تشکیل شده‌ است. هرکدام از این جفت‌ها دارای یک کلید (key) و مقدار (value) می‌باشند. کلیدها نمی‌توانند تکراری باشند و هر کلید مقدار خاص و یکتایی دارد. می‌توان به مقدار هر کلید با داشتن آن، دسترسی پیدا کرد و آن را تغییر داد. دقت کنید که کلیدها تغییرناپذیر هستند.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "74e3fb0a-6fd3-4163-9820-aae126132a0e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'ali': 12, 'amir': 2.3}\n",
      "12\n",
      "{'ali': 23, 'amir': 2.3}\n",
      "['ali', 'amir']\n"
     ]
    }
   ],
   "source": [
    "dict = {\"ali\": 12, \"amir\": 2.3}  # { key:value }\n",
    "\n",
    "print(dict)\n",
    "\n",
    "print(dict['ali']) # indexing in dict : dict[key] \n",
    "\n",
    "dict['ali'] = 23\n",
    "print(dict)\n",
    "\n",
    "print(list(dict))  # returns list of keys"
   ]
  },
  {
   "cell_type": "raw",
   "id": "c606ef63-57d0-4300-b004-714214fb3458",
   "metadata": {},
   "source": [
    ">>> print(dict())\n",
    "{}\n",
    ">>> dict([(\"ali\", 12), (\"amir\", 2.3)])\n",
    "{'ali': 12, 'amir': 2.3}\n",
    ">>> dict(ali=12, amir=2.3)       # only if keys are only string, this syntax is correct\n",
    "{'ali': 12, 'amir': 2.3}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "bbd253a2-3bfa-4683-86e1-928aa7503622",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'mohamadreza': 18, 'ali': 22}\n"
     ]
    }
   ],
   "source": [
    "# changing and adding to dict\n",
    "age = {'mohamadreza':17} \n",
    "age['ali'] = 22               # adding to dict, because the key ('ali') do not exist in the dict.\n",
    "age['mohamadreza'] = 18      # changing in dict, because the key ('mohamadreza') exists in dict.\n",
    "print(age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "fa507275-937c-4254-82ad-a77368d39242",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# access and finding a key in the dict\n",
    "\n",
    "square = {1: 1, 2: 4, 3: 9, 4: 16}\n",
    "print(3 in square)    # key in dictname\n",
    "print(square[3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "896e1e45-60bc-4aec-a07c-10cd61a81814",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    },
    {
     "ename": "KeyError",
     "evalue": "5",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_20156/4079454153.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m5\u001b[0m \u001b[1;32min\u001b[0m \u001b[0msquare\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msquare\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m: 5"
     ]
    }
   ],
   "source": [
    "print(5 in square)\n",
    "print(square[5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b2824de7-0761-4d01-8089-c08618ec8fbf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "{2: 4, 4: 16}\n"
     ]
    }
   ],
   "source": [
    "square = {1: 1, 2: 4, 3: 9, 4: 16}\n",
    "\n",
    "print(square.pop(3))\n",
    "\n",
    "del square[1]  # difference between pop() and del is that pop() returns value of removed key.\n",
    "\n",
    "print(square)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "33b59215-b0a7-4540-90bd-beea1603e8e5",
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "5",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_20156/3416015569.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0msquare\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpop\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# if the mentioned key do not exist, we see error ( KeyError )\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m: 5"
     ]
    }
   ],
   "source": [
    "square.pop(5) # if the mentioned key do not exist, we see error ( KeyError )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "906bc4d5-c8fd-462e-854a-22b5c8ad8600",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "19\n",
      "20\n"
     ]
    }
   ],
   "source": [
    "# dict.get(key, x)  if key do not exists, returns x \n",
    "\n",
    "grade = {'mamad': 20, 'ali':19, 'pooyan':19}\n",
    "print(grade.get('ali'))\n",
    "\n",
    "grade['mahdi'] = grade.get('mahdi', 19) + 1 \n",
    "print(grade.get('mahdi'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c452558a-bb39-4df3-8cbb-230972831805",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict_values'>\n",
      "<class 'dict_keys'>\n",
      "dict_values([21, 18, 22, 25])\n",
      "[21, 18, 22, 25]\n"
     ]
    }
   ],
   "source": [
    "# .values() and .keys() return an iterable.\n",
    "age = {'ali': 21, 'mmdreza': 18, 'mahdi': 22, 'pooyan':25}\n",
    "\n",
    "print(type(age.values()) )\n",
    "print(type(age.keys()))\n",
    "\n",
    "print(age.values())\n",
    "print(list(age.values()))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "890014ee-30cf-4b24-8206-203122b5866a",
   "metadata": {},
   "source": [
    "##### 2.8.4.1. dict comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b999b2cc-0013-4ab1-92eb-052eab29ed03",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}\n"
     ]
    }
   ],
   "source": [
    "dic = {x:x*x for x in range(5)}\n",
    "print(dic)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36048eba-b5aa-4082-9b77-651fcc71b306",
   "metadata": {},
   "source": [
    "##### 2.8.4.2. dict iteration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ab3def14-2885-4f63-a25b-2dd4ac628981",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ali got A\n",
      "amir got B\n"
     ]
    }
   ],
   "source": [
    "d = {'ali': 'A', 'amir': 'B'}\n",
    "for k, v in d.items():\n",
    "    print(k + \" got \" + v) \n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09882c0a-80eb-4479-8939-62cc7771ce5c",
   "metadata": {},
   "source": [
    "-----------------------------------\n",
    "- __\"len\" function__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "607c07fd-6baa-4798-ad25-826b6a3b9156",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "3\n",
      "2\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "print(len(\"Salam\"))    # len string  # counts characters of string\n",
    "print(len([1, 2, 3]))  # len list  # counts elements of list\n",
    "print(len({'ali': 'A', 'amir': 'B'})) # len dict   # counts keys of dict\n",
    "print(len(()))  # len tuple # counts element of tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ad2206b-3b65-41d6-abda-d1b297198615",
   "metadata": {},
   "source": [
    "\"len\" function is an example for polymorphism. \"len\" function calculates length of objects with different types."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed597a0d-5fb3-4567-818b-3a6c88902d33",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "------------------------------------\n",
    "### 2.9. ERRORS in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0aa66961-cd00-49d5-9ade-b0764c2c6445",
   "metadata": {},
   "source": [
    "#### 2.9.1. Syntax Error : Interpreter cannot find out the instruction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "98bf58e4-f1a2-4df7-8461-a2d50736ffc6",
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (Temp/ipykernel_15616/2651466651.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"C:\\Users\\mrzgh\\AppData\\Local\\Temp/ipykernel_15616/2651466651.py\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    while True print('Hello World!')\u001b[0m\n\u001b[1;37m               ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "while True print('Hello World!') "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ba961c2-df3c-4524-bdfb-d958f67695ce",
   "metadata": {},
   "source": [
    "- Identation Error : This error occurs when scoping is not correct."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "84183ca7-83ef-469a-be2b-71d6bb1f8aa0",
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "unexpected indent (Temp/ipykernel_15616/2099578784.py, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"C:\\Users\\mrzgh\\AppData\\Local\\Temp/ipykernel_15616/2099578784.py\"\u001b[1;36m, line \u001b[1;32m2\u001b[0m\n\u001b[1;33m    x = 2\u001b[0m\n\u001b[1;37m    ^\u001b[0m\n\u001b[1;31mIndentationError\u001b[0m\u001b[1;31m:\u001b[0m unexpected indent\n"
     ]
    }
   ],
   "source": [
    "print(\"salam\")    # first line also do not excute, because first, interpreter checks syntax of whole program, Then starts excuting.\n",
    "    x = 2\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eafcb6f4-7d4b-4877-9827-836b5a024d97",
   "metadata": {},
   "source": [
    "#### 2.9.2. Runtime Errors : When program runs, these errors show up. In python, called  __Exceptions__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "7d99b049-6254-4029-aa40-61c1f5118827",
   "metadata": {},
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_15616/2769744614.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mx\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m/\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "x = 1/0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "bfc12ddf-840d-4087-bd36-41a8340a04c4",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'y' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_15616/1056546137.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'y' is not defined"
     ]
    }
   ],
   "source": [
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "51fda8f2-d779-445d-b008-ba0be205ee6e",
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: 'salam'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_15616/3264160276.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mz\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'salam'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: invalid literal for int() with base 10: 'salam'"
     ]
    }
   ],
   "source": [
    "z = int('salam')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "168c50a9-681c-4cd2-a51b-3afe0f7a4164",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    به طور کلی ساختار خروجی استثناها توسط Interpreter به این ترتیب است که ابتدا مشخص می‌کند که در کدام بخش برنامه این خطا رخ‌ داده و stack traceback برنامه در آن زمان به چه شکل بوده‌است. در خط آخر نیز نوع استثنا به همراه یک توضیح کوتاه بعنوان دلیل رخ‌دادن خطا نمایش داده خواهد شد.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e75c313d-acd8-4073-8095-0a70f0b87a0b",
   "metadata": {},
   "source": [
    "##### 2.9.2.1. Exceptions Managment"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b5333ec-1fbe-4f0c-bf7f-0a8f524d2fc8",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    فرض کنید، می‌خواهیم کاری کنیم تا جلوی خطا دادن برنامه‌ را گرفته و خودمان خطا را مدیریت کنیم و حتی از این که بخشی از برنامه خطا می‌دهد استفاده کنیم تا کدی تمیزتر و با پیاده سازی راحت‌تر بنویسیم\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "3774ecef-d2db-4a69-8115-d424200dff35",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Quera\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It's just a string!\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    x = int(input())\n",
    "    print(\"It's a number!\")\n",
    "except Exception:\n",
    "    print(\"It's just a string!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "265abfdb-1892-4873-a0a4-204871c96c14",
   "metadata": {
    "tags": []
   },
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    شیوه کار دستور try به این صورت است که پس از نوشتن آن، در Scope بعد از آن دستوراتی که می خواهیم انجام شوند را می‌نویسیم. حال اگر در هنگام اجرای یکی از دستورات موجود در این محدوده، استثنایی رخ دهد برنامه از محدوده فعلی خارج شده و دستورات Scope ای که بعد از نوشتن except وجود دارد، اجرا می‌شود.\n",
    "    <br>\n",
    "    برای مثال در کد بالا ابتدا سعی می‌‌شود مقدار ورودی به int تبدیل شود. اگر استثنایی رخ ندهد در آن صورت عبارت It's a number! چاپ می شود؛ در غیر این صورت به Scope بعد از except رفته و عبارت It's just a string! چاپ می‌شود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8d23519-384d-45a0-b2f0-3508d63313b5",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "استثناها مانند مفاهیم دیگر پایتونی یک شئ هستند و می‌توانند انواع مختلفی داشته باشند.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "raw",
   "id": "f90feb70-cfec-484b-8bf0-d2dc6e9e1360",
   "metadata": {},
   "source": [
    ">>> int(input())\n",
    "'Quera'\n",
    "Traceback (most recent call last):\n",
    "  File \"<stdin>\", line 1, in <module>\n",
    "ValueError: invalid literal for int() with base 10: 'Quera'\n",
    ">>> "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6716e453-1b6a-4d4a-82cc-f095f1b16f3d",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "در مثال بالا خطای ValueError() رخ می‌دهد، که تابع int() آن را صدا کرده‌ است (چون ما به عنوان ورودی، رشته‌ی Quera را به تابع int دادیم و این تابع قابلیت تبدیل یک رشته به یک عدد را ندارد پس این خطا پرتاب شد). این قابلیت پایتون توانایی مدیریت متفاوت انواع خطاها را به ما می دهد.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42567f6b-5701-4e2a-a721-4a04721eb7c2",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "ک دستور try می‌تواند چندین except داشته باشد و استثنا‌های مختلفی را مدیریت کند. برای این کار نوع استثنا مقابل except نوشته می‌شود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ce4555b-2cdf-4552-979d-c3d3ce118a91",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "در ساختار try و except، ابتدا درون بخش try اجرا شده و اگر خطایی رخ دهد مفسر به exceptها توجه می‌کند؛ اگر در یکی از except‍ها خطایی از همان کلاس خطای رخ داده شده (و یا کلاسی که خطای رخ داده شده از آن ارث برده باشد) پیش‌بینی شده باشد، بخش درون آن except اجرا می‌شود. اگر چند except با این خاصیت وجود داشت؛ مفسر اولین (بالاترین از لحاظ متنی) except را انتخاب و بخش درون آن را اجرا می‌کند.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85a7ddda-1b03-46ab-a235-2c6e6ca6604d",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "مدیریت‌کننده‌ی (except)ها فقط می‌توانند استثنا‌هایی که در محدوده try رخ می‌دهد را مدیریت کنند و نمی‌توانند به استثنا‌های درون محدوده همدیگر دسترسی داشته باشند.\n",
    "<br>\n",
    "اگر جلوی هیچ exceptای خطای رخ داده شده پیش‌بینی نشده باشد unhandled exception رخ می‌دهد و اجرای برنامه متوقف می‌شود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "047b2513-66bb-41e9-9172-4d518c648141",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ZeroDivisionError called\n",
      "ValueError called\n",
      "TypeError called\n"
     ]
    }
   ],
   "source": [
    "for i in range(3):\n",
    "    try:\n",
    "        if i == 0:\n",
    "            1/0\n",
    "        if i == 1:\n",
    "            int(\"salam\")\n",
    "        if i == 2:\n",
    "            \"salam\" + 1\n",
    "    except ZeroDivisionError:\n",
    "        print(\"ZeroDivisionError called\") # 1/0\n",
    "    except TypeError:\n",
    "        print(\"TypeError called\") # \"salam\" + 1\n",
    "    except ValueError:\n",
    "        print(\"ValueError called\") # int(\"salam\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02bb499f-d168-4eb0-bb4f-d18549cff93c",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "همچنین اگر جلو except ،  Exception را بنویسیم تمام استثنا ها را مدیریت می کند.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "69c639c9-91c0-4baa-9aab-8944fde26765",
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    ...\n",
    "except Exception:\n",
    "    ..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f753c83-db3d-42d4-89e0-54ee80df6ba5",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "نکته : کلاس Exception والد تمام استثناها است؛ یعنی تمام استثنا‌ها به طور مستقیم یا غیرمستقیم از این کلاس ارث برده‌اند.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fff74eb9-8143-4794-a8cf-d8cef6c90082",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "یک دستور except می‌تواند چند نوع مختلف از خطا‌ها را مدیریت کند. نوع این خطاها درون پرانتز به شکل یک چندتایی (tuple) جلوی‌ دستور داده می‌شود. برای مثال:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "14cd45f6-b864-48a3-a8d7-79865e085763",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "an error occurred\n",
      "an error occurred\n",
      "an error occurred\n"
     ]
    }
   ],
   "source": [
    "for i in range(3):\n",
    "    try:\n",
    "            if i == 0:\n",
    "                    1/0\n",
    "            if i == 1:\n",
    "                    int(\"salam\")\n",
    "            if i == 2:\n",
    "                    \"salam\" + 1\n",
    "    except (ZeroDivisionError, TypeError, ValueError):\n",
    "            print(\"an error occurred\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb27fd5a-16ba-452c-be35-1428be285aa3",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    <h5> پرتاب کردن استثنا </h5>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff56e516-b3d2-4523-a6b0-a6ad463fd8d8",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "با دستور raise می‌توان یک استثنا را پرتاب کرد (یعنی کاری کنیم که یک استثنایی که خودمان می‌خواهیم داده شود).\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55a32f03-cef6-48ba-9a01-87e2e34fb2da",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "بعد از دستور raise باید یک شی از کلاس Exception یا یک کلاس Exception ( یا کلاسی که از Exception ارث برده است) بیاید. اگر یک کلاس به دستور raise داده شود یک شی با سازنده بدون آرگومان ساخته و آن را صدا می‌کند.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "9f197320-c827-4498-b671-2918b1ed67b5",
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_9220/335554213.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: "
     ]
    }
   ],
   "source": [
    "raise ValueError() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "9ced3f47-73a7-40bc-8ca7-a4551a3e0106",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "salam",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_9220/2793642340.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mNameError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'salam'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: salam"
     ]
    }
   ],
   "source": [
    "raise NameError('salam')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce39b86e-e20a-4cae-b875-7cde7063c13b",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "اگر بخواهیم استثنای صدا زده شده را مدیریت کنیم و دوباره آن را صدا کنیم؛ می‌توانیم یک دستور raise خالی بنویسیم تا خطای مدیریت شده را دوباره صدا کند.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "d84279ff-f862-4817-ba14-0e2af977d635",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "an exception raised\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "salam",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_9220/1632798180.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m     \u001b[1;32mraise\u001b[0m \u001b[0mNameError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'salam'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      3\u001b[0m \u001b[1;32mexcept\u001b[0m \u001b[0mNameError\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'an exception raised'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m     \u001b[1;32mraise\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: salam"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    raise NameError('salam')\n",
    "except NameError:\n",
    "    print('an exception raised')\n",
    "    raise "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9039197-3d70-49f5-a159-49891504f7f2",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "همان‌طور که می‌بینید در محدوده except NameError فقط کلمه raise آمده است. چنین چیزی همان کاری را می‌کند که raise NameError انجام می‌دهد.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d06f1f2-31c3-4eb5-8f5b-89a5ee18d0e6",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    <h6> 2.9.2.1.1. تعریف کردن استثنا </h6>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b984df34-5dc2-4436-a5ab-e8fa4439ff53",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "برای تعریف استثناهای‌ خود می‌توانیم یک کلاس تعریف کنیم که مستقیم یا غیرمستقیم از کلاس Exception ارث ببرد.\n",
    "<br>\n",
    "کلاس‌های استثنا می‌توانند مانند بقیه کلاس‌ها خصوصیات مختلفی داشته باشند ولی معمولا ساده تعریف می‌شوند و فقط خصوصیات کاربردی در مدیریت را در خود نگه‌ می‌دارند.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "eb3792ba-81d7-4baa-b1d7-195987fe58ab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "exception found <class '__main__.C'>\n"
     ]
    }
   ],
   "source": [
    "class A(Exception):\n",
    "    pass\n",
    "class B(A):\n",
    "    pass \n",
    "class C(B):\n",
    "    pass\n",
    "try:\n",
    "    raise C\n",
    "except A as e:\n",
    "    print('exception found', type(e))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be63b69a-c8db-4aa8-b34b-867562129e39",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "در کد بالا کلاس C به صورت غیرمستقیم از کلاس ‍A ارث بری می‌کند در نتیجه یک کلاس استثنا است.\n",
    "با استفاده از کلیدواژه raise می‌توان یک استثنا را پرتاب کرد.\n",
    "می‌توان بعد از except کلیدواژه as و سپس نام یک متغیر را نوشت و در آن صورت آن استثنا درون متغیر ریخته می‌شود که می‌توان در محدوده except از آن استفاده کرد.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3b27161-52e3-4855-bcba-f7d6d860cc7a",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "<h6> 2.9.2.1.2. استفاده از کلید واژه else </h6>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e5487bf-166b-43af-bc5b-07e32b3fb53d",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "با استفاده از عبارت else، می‌توان محدوده‌ای را مشخص کرد که در صورت عدم بروز استثنا، اجرا شود. ‍‍‍\n",
    "</div>"
   ]
  },
  {
   "cell_type": "raw",
   "id": "0f7c3700-93d2-4997-b276-861953c8b341",
   "metadata": {},
   "source": [
    "try:\n",
    "    run_testcase(case)\n",
    "except Exception:\n",
    "    tests_failed += 1\n",
    "    print('F', end='')\n",
    "else:\n",
    "    test_passed +=1\n",
    "    print('P', end='')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ce04124-c03c-4837-8cc2-63656d4284b1",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "قطعه کد بالا یک تست را اجرا می‌کند و در صورتی که تست با شکست مواجه شود (استثنا رخ دهد)؛ به تعداد تست های ناموفق یک واحد اضافه می‌شود و پیام شکست چاپ می‌شود و در صورت پاس شدن تست‌ها به تعداد تست های موفق یک واحد اضافه می‌شود و پیام موفقیت چاپ می‌شود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "312c94d4-d2a9-4260-8a48-44c4e182636f",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "<h6> 2.9.2.1.3. استفاده از کلید واژه finally </h6>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c63d00d-1acc-4e08-b1aa-0994ddf9efff",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "دستوراتی که در محدوده بعد از finally نوشته می‌شوند، در هر شرایطی که برای محدوده try رخ دهد اجرا می‌شوند.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "b52754f0-cb04-4326-a558-1a06166e9d5b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "error!!\n",
      "finally is running\n"
     ]
    },
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_9220/4004570218.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m     \u001b[1;36m1\u001b[0m\u001b[1;33m/\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      3\u001b[0m \u001b[1;32mexcept\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'error!!'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m     \u001b[1;32mraise\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    1/0\n",
    "except:\n",
    "    print('error!!')\n",
    "    raise\n",
    "finally:\n",
    "    print('finally is running')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2142ec9-4b42-41c8-81e8-226092f2f55e",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "همان‌طور که می‌بینید با اینکه یک استثنا رخ داد و مدیریت نشد باز محدوده finally اجرا شد.\n",
    "با وجود اینکه تابع در محدوده try مقداری برمی‌گرداند و مفسر از تابع خارج می‌شود؛ محدوده finally اجرا می‌شود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c75e2c60-ca2a-4308-8997-3a29217dffe0",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    <b> عکس زیر ساختار کلی یک مدیریت خطا در پایتون است. </b>\n",
    "    <br>\n",
    "    <img src = \"https://files.realpython.com/media/try_except_else_finally.a7fac6c36c55.png\" height = 500px width = 800px >\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bfb4b115-42a9-41d8-9c75-b8a7550f5a8e",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "---------------------\n",
    "### 2.10. OOP"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d2c9c75-81a2-4903-ad22-a4e1e6eca761",
   "metadata": {},
   "source": [
    "#### 2.10.1. class Definition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c1503c8d-b95f-4fa8-a246-9bcee5a365f5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.Game'>\n",
      "<class 'type'>\n"
     ]
    }
   ],
   "source": [
    "class Game():\n",
    "    pass\n",
    "\n",
    "\n",
    "game = Game()  # Instantiation of class game\n",
    "print(type(game))\n",
    "print(type(Game))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9231e0bf-0a85-49cb-9a1e-2c6d80ba6344",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    در این مثال ابتدا یک کلاس به نام Game تعریف کرده‌ایم و سپس یک شئ از آن جنس ساخته‌ایم و سپس نوع شئ را گرفته‌ایم که از نوع Game است (__main__ به این معناست که این کلاس در همین فایل تعریف شده‌ است).\n",
    "</div>\n",
    "- all classes inherit from class 'object' as default."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b18e74ca-5c57-47e8-b258-cd46aa16ed57",
   "metadata": {},
   "source": [
    "##### 2.10.1.1. Attribute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "3f2b4516-6467-48c6-85f2-3fd7a8074214",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mohamadreza\n",
      "18\n"
     ]
    }
   ],
   "source": [
    "class Person():\n",
    "    def __init__ (self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        pass\n",
    "    pass \n",
    "\n",
    "p1 = Person('mohamadreza', 18)\n",
    "print(p1.name)\n",
    "print(p1.age)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da44d0f8-225b-4c29-9ae1-9d6e4684c611",
   "metadata": {},
   "source": [
    "##### 2.10.1.2. Method"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41a33851-43bd-4a9b-93c5-d609f39fa1de",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    می‌توان برای شئ، توابعی (methods) تعریف کرد که روی آن اعمال شوند و ویژگی‌های (properties) آن را تغییر دهند. برای این کار باید تابعی درون کلاس تعریف کرد که اولین ورودی آن self باشد. self در واقع نماینده همان شیئی است که تابع روی آن فراخوانی می‌شود. حال می‌توانیم از self به عنوان شئ استفاده کنیم و برای آن ویژگی‌های جدیدی تعریف و مقداردهی کنیم یا حتی ویژگی‌های قبلی آن را تغییر دهیم.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "34bcfe1e-11c7-4a51-89f7-9699405058a5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "class Game():\n",
    "     def set_money(self, money):\n",
    "        self.money = money\n",
    "        pass\n",
    "     def get_money(self):\n",
    "        return self.money\n",
    "        \n",
    "game = Game()\n",
    "\n",
    "Game.set_money(game, 5)\n",
    "print(Game.get_money(game))\n",
    "\n",
    "game.set_money(4)\n",
    "print(game.get_money())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc06cefd-67b3-4f54-89cf-af68cdf31c1f",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    همان گونه که مشاهده می‌کنید اگر تابع set_money یا get_money را روی خود شئ صدا بزنیم، نیازی نیست self را ورودی دهیم چون مقدارش برابر با خود شئ در نظر گرفته می‌شود. اما اگر آن را بر روی کلاس Game اجرا کنیم باید شئ مورد نظر را ورودی دهیم تا مفسر بفهمد که باید تابع را روی کدام شئ اجرا کند.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "503f2808-0179-40b4-a25a-5d93f24c3488",
   "metadata": {},
   "source": [
    "##### 2.10.1.3.  Constructor"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0041beb0-22e8-42e1-bd17-e99b21edcf37",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    می‌توان در هنگام ساختن یک شئ از یک کلاس، ویژگی‌های (properties) آن را مقداردهی کرد. برای این کار باید تابع __init__ کلاس را تعریف کنیم. در صورتی که این تابع را تعریف نکنیم، کلاس به طور پیش‌فرض ورودی‌ نمی‌گیرد و اشیاء آن مانند مثال قبل به طور ساده ساخته می‌شوند. این تابع مانند توابع دیگری که برای کلاس تعریف کردیم، ‍‍self را ورودی می‌گیرد. البته می‌توان ورودی‌های دیگری را نیز دریافت کرد. حتی می‌توان برای هرکدام از آن‌ها مقدار پیش‌فرضی تعیین کرد تا در صورتی که هنگام ساختن شئ جدید مقداردهی نشوند، مقدار پیش‌فرض برای آن‌ها در نظر گرفته شوند.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4080450-ae7c-4b08-941f-f593547e1d47",
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> class Person():\n",
    "...     def __init__(self, name, age=18):\n",
    "...         self.name = name\n",
    "...         self.age = age\n",
    "...\n",
    ">>> p1 = Person(\"Ali\", 12)\n",
    ">>> p2 = Person(\"Amir\")\n",
    ">>> p1.name\n",
    "'Ali'\n",
    ">>> p1.age\n",
    "12\n",
    ">>> p2.name\n",
    "'Amir'\n",
    ">>> p2.age\n",
    "18"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c19a596-8701-496d-8e9f-42a0d0c273fe",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    اگر می‌خواستیم به روش مثال پیشین عمل کنیم باید برای هر شیئی که از کلاس Person ساخته می‌شود، پس از ساخته شدن، به طور جداگانه ویژگی‌های name و age را تعریف می‌کردیم؛ اما با به‌کارگیری متد __init__ تضمین می‌شود همه اشیائی که از این کلاس ساخته می‌شوند، این دو ویژگی را دارا خواهند بود چرا که هنگام ساخته شدن (نه بعد از ساخته شدن) این دو ویژگی مقداردهی می‌شوند.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7228e848-b6b5-4b5d-a645-7b5d234c3e1b",
   "metadata": {},
   "source": [
    "##### 2.10.1.4. Static Variable"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5a27e16-68e9-4028-bd10-35cd79e93e22",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "   متغیر ایستا متغیری است که به شئ ساخته شده ربطی ندارد و برای خود کلاس است. البته از شئ می‌توان به متغیرهای ایستا دسترسی داشت ولی نمی‌توان مقدار آن‌ها را تغییر داد. برای تعریف این نوع متغیر می‌توان در محدوده مربوط به کلاس، یک متغیر تعریف و مقداردهی کرد. سپس از کلاس موردنظر می‌توان به آن دسترسی داشت و آن را تغییر داد. اگر ویژگی‌ای از کلاس را مقداردهی کنیم که به صورت استاتیک در کلاس موردنظر وجود ندارد، آن ویژگی مقدار خواسته‌شده را می‌گیرد و به فضای نام مربوط به کلاس اضافه می‌شود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1b3de445-fa7a-4332-b26c-a966173cad2b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3000\n",
      "3000\n",
      "2000\n",
      "3000\n"
     ]
    }
   ],
   "source": [
    "class Game():\n",
    "    goal_money = 3000\n",
    "\n",
    "    def set_money(self, x):\n",
    "        self.money = x\n",
    "        pass\n",
    "\n",
    "    def get_money(self):\n",
    "        return self.money\n",
    "    pass\n",
    "\n",
    "print(Game.goal_money)   # = 3000\n",
    "\n",
    "game = Game()\n",
    "print(game.goal_money)   # = 3000\n",
    "\n",
    "game.goal_money = 2000\n",
    "print(game.goal_money)   # = 2000\n",
    "\n",
    "Game.goal_money\n",
    "\n",
    "del game.goal_money\n",
    "print(game.goal_money)   # = 3000"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65193972-55c6-4f34-baf2-fda6f599e722",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    ابتدا، یک شئ از کلاس می‌سازیم. در خط بعد مقدار goal_money از طریق آن شئ چاپ می‌شود، از آن‌جایی که این شئ به متغیرهای ایستا دسترسی مشاهده (read-only) دارد، مقدار ۳۰۰۰ چاپ می‌شود.\n",
    "<br>\n",
    "سپس در خط ۱۸، مقدار goal_money را برای آن شئ تغییر می‌دهیم اما از آن جا که شئ به متغیرهای ایستا دسترسی تغییر ندارد، یک ویژگی به خود شئ اضافه می‌شود و در خط بعد سپس مقدار آن چاپ می‌شود. برای اینکه مطمئن شویم مقدار متغیر ایستا تغییر نکرده است در خط ۲۱ مقدار آن‌ را دوباره از طریق کلاس چاپ می‌کنیم.\n",
    "<br>\n",
    "در دو خط بعد ویژگی goal_money را که به شئ اضافه شده بود و برابر ۲۰۰۰ بود پاک می‌کنیم. حال اگر goal_money را از طریق شئ بخوانیم برابر متغیر ایستای کلاس خواهد بود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac8a66b0-b265-40cf-a8a8-1bc5e38e586c",
   "metadata": {},
   "source": [
    "##### 2.10.1.5. Static Method"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10f4cc77-a86f-49c6-886a-33bb689b2558",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    تایع ایستا تابعی است که روی کلاس تعریف می‌شود و دیگر دسترسی‌ به شی‍ئی که از آن تابع را صدا زدیم ندارد. در واقع می‌توان حتی بدون ساختن شئ از آن استفاده کرد. برای تعریف چنین تابعی قبل از تعریف تابع @staticmethod می‌نویسم، سپس شروع به نوشتن تابع می‌کنیم. @staticmethod یک annotation است.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "3adc7453-8225-434b-8269-fea3a918ee50",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3000\n",
      "3100\n"
     ]
    }
   ],
   "source": [
    "class Sample():\n",
    "    goal_money = 3000   \n",
    "\n",
    "    @staticmethod \n",
    "    def increase_goal_money(value):\n",
    "        Sample.goal_money += value\n",
    "        pass\n",
    "\n",
    "sample = Sample()\n",
    "print(Sample.goal_money)\n",
    "Sample.increase_goal_money(100)\n",
    "print(sample.goal_money)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e422cf1c-038e-4c81-b1c2-f15e583621a7",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    همان‌طور که دیدید تابع ایستا، self را به عنوان ورودی نمی‌گیرد. به همین علت در تابع ایستا نمی‌توان تشخیص داد این تابع توسط چه شیئی صدا زده شده است. با اجرا کردن این کد خواهید دید که خروجی زیر چاپ می‌شود و با صدا زدن تابع ایستای increase_goal_money، مقدار متغیر ایستای goal_money افزایش می‌یابد.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35b1b6f4-87fa-4da5-85ed-d810c4e8d52c",
   "metadata": {},
   "source": [
    "##### 2.10.1.6. Protected members"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35296bc4-54cd-4029-bc1c-9ba3a977a20e",
   "metadata": {},
   "source": [
    "Python's convention to make an instance variable protected is to add a prefix _ (single underscore) to it. This effectively prevents it from being accessed unless it is from within a sub-class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "8b4df3e4-d876-4770-8d1a-e5d06f8864fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Student:\n",
    "    _schoolName = 'XYZ School' # protected static variable\n",
    "    \n",
    "    def __init__(self, name, age):\n",
    "        self._name=name  # protected instance attribute\n",
    "        self._age=age # protected instance attribute"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30c75db7-357b-4142-9de6-eeabb43d4719",
   "metadata": {},
   "source": [
    "In fact, this doesn't prevent instance variables from accessing or modifying the instance. You can still perform the following operations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "2b455ab8-33df-4753-8e7e-6ebd28b2daad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Swati\n",
      "Dipa\n"
     ]
    }
   ],
   "source": [
    "std = Student(\"Swati\", 25)\n",
    "print(std._name)\n",
    "std._name = 'Dipa'\n",
    "print(std._name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81628de7-4d26-4b62-a6b3-21860131cd5b",
   "metadata": {},
   "source": [
    "Hence, the responsible programmer would refrain from accessing and modifying instance variables prefixed with _ from outside its class."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1cc34561-22d7-400b-ae14-f251dea13ef3",
   "metadata": {},
   "source": [
    "##### 2.10.1.7. Private Members"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5dcf4ad-c0ba-4156-bdf7-81d2d22ba07e",
   "metadata": {},
   "source": [
    "The double underscore __ prefixed to a variable makes it private. It gives a strong suggestion not to touch it from outside the class. Any attempt to do so will result in an AttributeError:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "366d4d98-b1ba-4537-a856-19ee6dbd10e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Student:\n",
    "    __schoolName = 'XYZ School' # private class attribute\n",
    "\n",
    "    def __init__(self, name, age):\n",
    "        self.__name=name  # private instance attribute\n",
    "        self.__salary=age # private instance attribute\n",
    "    def __display(self):  # private method\n",
    "        print('This is private method.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "185ca7a8-7ec8-44b6-b777-443fc1fe0dec",
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Student' object has no attribute '__schoolName'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_3692/593255032.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mstd\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mStudent\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Bill\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m25\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mstd\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__schoolName\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: 'Student' object has no attribute '__schoolName'"
     ]
    }
   ],
   "source": [
    "std = Student(\"Bill\", 25)\n",
    "\n",
    "std.__schoolName"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "940e7e25-c356-4a98-909c-c8c3730210f2",
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Student' object has no attribute '__name'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_3692/1120992331.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mstd\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__name\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: 'Student' object has no attribute '__name'"
     ]
    }
   ],
   "source": [
    "std.__name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "a3cbcad9-07fd-4cb5-abed-38efe85e92a2",
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Student' object has no attribute '__display'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_3692/4181530199.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mstd\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__display\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: 'Student' object has no attribute '__display'"
     ]
    }
   ],
   "source": [
    "std.__display()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4772d924-16e3-4889-88e1-4f8e170d0a37",
   "metadata": {},
   "source": [
    "Python performs name mangling of private variables. Every member with a double underscore will be changed to _object._class__variable. So, it can still be accessed from outside the class, but the practice should be refrained."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "43b5cef5-0067-49e9-9195-1d1ad022d321",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bill\n",
      "Steve\n",
      "This is private method.\n"
     ]
    }
   ],
   "source": [
    "std = Student(\"Bill\", 25)\n",
    "print(std._Student__name)\n",
    "std._Student__name = 'Steve'\n",
    "print(std._Student__name)\n",
    "std._Student__display()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03f2299c-5e88-49fd-8ed4-54ba95256200",
   "metadata": {},
   "source": [
    "#### 2.10.2. Polymorphism in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "5145bd36-274f-41aa-8fa2-a8b161dd13d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Account:\n",
    "    def __init__(self, full_name, username, password):\n",
    "        self.full_name = full_name\n",
    "        self.username = username\n",
    "        self.password = password\n",
    "        self.courses = []   \n",
    "\n",
    "    def add_course(self, new_course):\n",
    "        self.courses.append(new_course)\n",
    "        pass\n",
    "    pass\n",
    "class Student(Account):\n",
    "    def __init__(self, full_name, username, password, rank_in_college):\n",
    "        super().__init__(full_name, username, password)\n",
    "        self.rank_in_college = rank_in_college\n",
    "\n",
    "    def get_rank(self):\n",
    "        return f'Student {self.full_name} rank in the college is {self.rank_in_college}!' \n",
    "\n",
    "class Professor(Account):\n",
    "    def __init__(self, full_name, username, password, h_index_rank):\n",
    "        super().__init__(full_name, username, password)\n",
    "        self.h_index_rank = h_index_rank   \n",
    "\n",
    "    def get_rank(self):\n",
    "        return f'Professor {self.full_name} H-Index rank is {self.h_index_rank}!' \n",
    "    pass\n",
    "\n",
    "ali = Student('Ali Safinal', 'safinal', '@Li2001', 13)\n",
    "seyed = Professor('Seyed Ali Babaei', 'SalibeBaSalabat1234', '786ff912', 80)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "16d292b8-bc69-410b-9470-cac04cdf2024",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Student Ali Safinal rank in the college is 13!\n"
     ]
    }
   ],
   "source": [
    "print(ali.get_rank())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e93b0607-80f1-4528-a44f-babb774eeddb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Professor Seyed Ali Babaei H-Index rank is 80!\n"
     ]
    }
   ],
   "source": [
    "print(seyed.get_rank())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38b61bcd-2b3e-46d0-b9e7-25500edbb466",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    با وجود اینکه نام متد در هر دو حالت یکسان است ولی کارکرد آن برای شیء استاد کاملا متفاوت با شیء دانشجو است.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81adeff1-03c2-493a-97ee-59a0b9b9d123",
   "metadata": {},
   "source": [
    "#### 2.10.3.  Inheritance in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51d29614-c697-48cd-b8aa-a5c6c6d0bf87",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "در ارث‌بری یک کلاس می‌تواند تمام ویژگی‌ها، شامل توابع و متغیرهایی که در یک کلاس دیگر تعریف شده‌اند را به خودش انتقال دهد. در این عملیات به کلاسی که ويژگی‌ها را می‌گیرد فرزند و به کلاسی که ویژگی‌ها را می‌دهد پدر می‌گویند.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "45b2650d-e0e4-4d4b-b506-60c82a36517b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Parent():\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        pass\n",
    "    pass\n",
    "class Child(Parent):\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        pass\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "997612cd-46de-4325-b283-22e6b1b3da10",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "برای ارث‌بری در پایتون کافی‌ست در زمان تعریف کلاس فرزند، نام کلاس پدر را به عنوان ورودی به فرزند بدهیم. توجه کنید که برای این کار کلاس پدر حتما باید قبل از کلاس فرزند تعریف شده‌‌باشد. همچنین اگر برای یک کلاس پدری مشخص نکنیم، به طور پیش‌فرض object به‌عنوان پدرش در نظر گرفته می‌شود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1f935bf8-bb3b-4b7c-bd35-944ebb8f20ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person():\n",
    "    def __init__(self, name):\n",
    "        self.name = name"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa2f53a1-f3ce-461e-be4a-535d0060c2d2",
   "metadata": {},
   "source": [
    "##### 2.10.3.1. using of \"super\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "bcfaf75e-a4fb-42d1-b1d3-2c62d0b70217",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person(object):\n",
    "    def __init__(self, name):\n",
    "        self.name = name"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58063a80-510d-4d5c-92a7-05346f0ee63c",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "در بخش بالا دیدیم که چطور می‌توانیم از یک کلاس ارث‌بری کنیم و حالا می‌خواهیم به این بپردازیم که چطور از توابع کلاس پدر در کلاس فرزند استفاده کنیم.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54a7bf85-f230-4c60-92e4-42e99e9095ab",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "پایتون دارای تابعی به نام super می‌باشد که با استفاده از آن، در داخل کلاس فرزند می‌توان به توابع کلاس پدر دسترسی داشت و از آن‌ها استفاده کرد.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e4e9d595-eb2e-4d23-b801-cbff3db8320c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initialize from class Engineer\n",
      "Initialize from class Person\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self):\n",
    "        print('Initialize from class Person')\n",
    "\n",
    "class Engineer(Person):\n",
    "    def __init__(self):\n",
    "        print('Initialize from class Engineer')\n",
    "        super().__init__()\n",
    "\n",
    "eng = Engineer()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78a66182-e417-4f21-86bf-abad87d0ebaa",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "برای مثال فرض کنید تابعی در کلاس پدر وجود دارد و ما تابعی با همان اسم در کلاس فرزند تعریف کرده‌ایم. در آن صورت با صدا زدن آن تابع، تابعی که در کلاس فرزند وجود دارد صدا می‌شود و اگر بخواهیم تابع کلاس پدر را صدا بزنیم می‌توانیم از super استفاده کنیم. برای درک این موضوع به مثال زیر دقت کنید:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a8e7f857-3855-416d-8c75-73a7d2e77b99",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initialize from class Engineer\n",
      "Output from class Engineer\n",
      "Output from class Person\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self):\n",
    "        print('Initialize from class Person')\n",
    "\n",
    "    def output(self):\n",
    "        print('Output from class Person')\n",
    "\n",
    "class Engineer(Person):\n",
    "    def __init__(self):\n",
    "        print('Initialize from class Engineer')\n",
    "\n",
    "    def output(self):\n",
    "        print('Output from class Engineer')\n",
    "        super().output()\n",
    "\n",
    "sepehr= Engineer()\n",
    "sepehr.output()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07c29648-51a9-4df6-b47c-a9d80f3ca463",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "در این مثال ما شئ‌ای از کلاس ‍‍Engineer ایجاد کرده و تابع ‍‍output را فراخوانی می‌کنیم. در هنگام ایجاد این آبجکت، تابع __init__ مربوط به کلاس ‍‍Engineer صدا زده می‌شود و هنگام فراخوانی تابع output، می‌بینیم که تابع super، تابع output مربوط به کلاس Person را هم صدا می‌زند و این‌گونه است که هم پیام مربوط به تابع output کلاس Engineer و هم پیام مربوط به تابع output کلاس Person با توجه به ترتیبی که آمده‌اند، صدا زده می‌شوند.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1acac1b5-94ba-4313-b561-2afd37788690",
   "metadata": {},
   "source": [
    "##### 2.10.3.2. Multi-Inheritance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "013892e1-ae1a-4f60-b21c-09dc8cd5e52d",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Rooster:\n",
    "    pass\n",
    "\n",
    "class Hen:\n",
    "    pass\n",
    "\n",
    "class Chick(Rooster, Hen):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "705cfb9a-b747-4acb-b912-c0f8aba21731",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "در مثال بالا، کلاس Chick هم‌زمان از کلاس‌های Rooster و Hen ارث‌ برده‌ است و می‌تواند از ویژگی‌های هر دوی این کلاس‌ها استفاده کند.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1447d5cf-f8e6-43ab-8a48-654cd8215064",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "حال فرض کنید که کلاس‌هایی که از آن‌ها ارث‌بری کرده‌ایم؛ دارای ویژگی‌ مشترکی باشند. در این صورت، با صدا زدن آن ویژگی در کلاس فرزند، آن ویژگی از بین کدام یک از کلاس‌های پدر انتخاب می‌شود؟\n",
    "پاسخ این است که در صورتی که کلاس‌هایی که از آن ارث برده شده ویژگی‌های یکسانی داشته باشند، آن ویژگی از اولین کلاسی که نوشته شده ارث برده می‌شود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "399002f1-90a9-4ee7-82ca-3ed7e3e53fbb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In Rooster class.\n",
      "Hello my baby!\n"
     ]
    }
   ],
   "source": [
    "class Rooster:\n",
    "    def name(self):\n",
    "        print('In Rooster class.')\n",
    "\n",
    "class Hen:\n",
    "    def name(self):\n",
    "        print('In Hen class.')\n",
    "    def hello(self):\n",
    "        print('Hello my baby!')\n",
    "\n",
    "class Chick(Rooster, Hen):\n",
    "    pass\n",
    "\n",
    "x = Chick()\n",
    "x.name()\n",
    "x.hello()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83cd71ad-f652-4e5f-b736-3ac746db1d1a",
   "metadata": {},
   "source": [
    "###### 2.10.3.2.1. using \"super\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "7fde86d5-c1fd-44fb-9607-91b779e8876a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initialize from class Rectangle\n",
      "Initialize from class Shape\n",
      "Initialize from class Rhombus\n",
      "Initialize from class Shape\n"
     ]
    }
   ],
   "source": [
    "class Shape:\n",
    "    def __init__(self):\n",
    "        print('Initialize from class Shape')\n",
    "\n",
    "class Rectangle(Shape):\n",
    "    def __init__(self):\n",
    "        print('Initialize from class Rectangle')\n",
    "        Shape.__init__(self)\n",
    "\n",
    "class Rhombus(Shape):\n",
    "    def __init__(self):\n",
    "        print('Initialize from class Rhombus')\n",
    "        Shape.__init__(self)\n",
    "\n",
    "class Square(Rectangle, Rhombus):\n",
    "    def __init__(self):\n",
    "        Rectangle.__init__(self)\n",
    "        Rhombus.__init__(self)\n",
    "\n",
    "squ = Square()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9f09b83-7720-4733-9e5c-81745a6f9371",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "اگر دقت کرده باشید می‌بینید که تابع ‍‍__init__ کلاس Shape در اینجا ۲ بار تکرار شده است و این مسئله اشتباه است. چون درست است که هر دو کلاس Rectangle و Rhombus از کلاس Shape ارث‌بری کرده‌اند ولی برای کلاس Square نباید تابع مربوط به کلاس Shape ۲ بار تکرار می‌شد. حالا اگر از شیٔ super استفاده کنیم این مشکل رفع می‌شود. به کد زیر دقت کنید:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "59943e9c-c545-49fa-8117-f044059134ad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initialize from class Rectangle\n",
      "Initialize from class Rhombus\n",
      "Initialize from class Shape\n"
     ]
    }
   ],
   "source": [
    "class Shape:\n",
    "    def __init__(self):\n",
    "        print('Initialize from class Shape')\n",
    "\n",
    "class Rectangle(Shape):\n",
    "    def __init__(self):\n",
    "        print('Initialize from class Rectangle')\n",
    "        super().__init__()\n",
    "\n",
    "class Rhombus(Shape):\n",
    "    def __init__(self):\n",
    "        print('Initialize from class Rhombus')\n",
    "        super().__init__()\n",
    "\n",
    "class Square(Rectangle, Rhombus):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "\n",
    "squ = Square()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb02835f-4a95-4ba3-81e4-ce286e71ef43",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "در نتیجه بهتر است در ارث بری از شیٔ super استفاده کنید که کدتان دچار این چنین مشکلات احتمالی نشود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32c2fcd9-d50c-45e5-af44-100fc9348ae1",
   "metadata": {},
   "source": [
    "#### 2.10.4. getter and setter"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "642fd0b1-9901-4058-815d-ae5d416fda7d",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "getter و setter در بسیاری از زبان‌های شئ‌گرا استفاده می‌شوند. اگر تجربه کار با دیگر زبان‌های برنامه‌نویسی شئ‌گرا مانند java را داشته باشید شاید تصور کنید روش مناسب پیاده سازی کلاس، استفاده از متغیرهای خصوصی است؛ اما در پایتون ترجیح بر این است که بیشتر از متغیرهای عمومی استفاده شود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "f2f59881-648f-4f39-81fd-6f1f7621ab74",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n",
      "50\n"
     ]
    }
   ],
   "source": [
    "class First:\n",
    "\n",
    "    def __init__(self, x):\n",
    "        self.__x = x\n",
    "\n",
    "    def get_x(self):\n",
    "        return self.__x\n",
    "\n",
    "    def set_x(self, x):\n",
    "        self.__x = x\n",
    "        pass\n",
    "    pass\n",
    "obj1 = First(42)\n",
    "obj2 = First(4711)\n",
    "print(obj1.get_x())\n",
    "obj1.set_x(50)\n",
    "print(obj1.get_x())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "7828046c-0031-4e15-966f-baff105a9dd1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4761\n"
     ]
    }
   ],
   "source": [
    "obj1.set_x(obj1.get_x()+obj2.get_x())\n",
    "print(obj1.get_x())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca2451b7-fa86-4c76-932c-a5a9f7b077ec",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "به قطعه کد بالا دقت کنید. مسلما عبارت obj1.set_x(obj1.get_x() + obj2.get_x()) نسبت به obj1.x = obj1.x + obj2.x عبارت ناخواناتری است.\n",
    "    <br>\n",
    "    پس اجازه دهید کلاسی مانند کلاس بالا را به روشی پایتونی‌تر بازنویسی کنیم:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "dbebe75a-7ee9-4f02-a2b2-35565ffcebab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n",
      "4754\n"
     ]
    }
   ],
   "source": [
    "class Second:\n",
    "\n",
    "    def __init__(self, x):\n",
    "        self.x = x\n",
    "        pass\n",
    "    pass\n",
    "obj1 = Second(42)\n",
    "obj2 = Second(4711)\n",
    "print(obj1.x)\n",
    "obj1.x = 43\n",
    "obj1.x = obj1.x + obj2.x\n",
    "print(obj1.x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "724b567a-f6e8-4648-94f8-b3b4585b1c89",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "مسلما این کد از حالت قبل خواناتر است؛ اما ممکن است بگویید: \"خب، پس Data Encapsulation وجود نداره؟ ...\" در جواب باید گفت بله، در این مورد data Encapsulation وجود ندارد؛ در واقع به آن نیازی نیست. تنها کاری که ‍get_x و set_x در مثال اولیه انجام می‌داد، دادن و گرفتن متغیر بدون هیج کار اضافه‌ای بود.\n",
    "<br>\n",
    "ولی اگر در آینده بخواهیم پیاده سازی را تغییر دهیم چه؟ این مسئله‌ی جدی‌ای است. فرض کنید بخواهیم پیاده‌سازی را به این صورت تغییر دهیم که:\n",
    "<br>\n",
    "متغیر x مقادیری بین ۰ و ۱۰۰۰ می‌تواند داشته باشد، اگر مقداری بزرگتری از ۱۰۰۰ به آن assign شد باید برابر ۱۰۰۰ قرار گیرد و اگر برابر مقداری کمتر از ۰ قرار گرفت باید برابر ۰ شود.\n",
    "برای حالت اول (کلاس First) کار راحت‌تر است و می‌توان کد را مطابق مورد پایین تغییر داد:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e4cfb891-1ea2-455c-84a7-4a5595ad4a08",
   "metadata": {},
   "outputs": [],
   "source": [
    "class First:\n",
    "\n",
    "    def __init__(self, x):\n",
    "        self.set_x(x)\n",
    "\n",
    "    def get_x(self):\n",
    "        return self.__x\n",
    "\n",
    "    def set_x(self, x):\n",
    "        if x < 0:\n",
    "            self.__x = 0\n",
    "        elif x > 1000:\n",
    "            self.__x = 1000\n",
    "        else:\n",
    "            self.__x = x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "fa2ee920-7f9b-4cbf-897c-b5f257465df9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1001\n",
      "15\n",
      "-1\n"
     ]
    }
   ],
   "source": [
    "\n",
    "obj1 = First(1001)\n",
    "print(obj1.get_x())\n",
    "\n",
    "obj2 = First(15)\n",
    "print(obj2.get_x())\n",
    "\n",
    "obj3 = First(-1)\n",
    "print(obj3.get_x())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82d87235-d2b2-4115-91d0-a660f0226922",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "اما اگر کلاس را مانند حالت دوم (کلاس Second) طراحی می‌کردیم و قصد داشتیم تغییرات گفته شده را برروی آن اعمال کنیم، چه؟ اگر سعی کنیم این کلاس را با روش قبلی جایگزین کنیم، کلاس جدید باعث ایجاد خطا در سایر قسمت‌های کد می‌شود (متغیر x در آن قسمت‌ها در دسترس نمی‌باشد). به همین علت است که در بعضی از زبان های شئ‌گرا توصیه می‌شود از متغیرهای خصوصی استفاده شود. ولی در پایتون نیاز به رعایت چنین اصلی ندارید.\n",
    "<br>\n",
    "پایتون برای حل این مشکل راه‌حلی ارائه می‌کند که متفاوت با این زبان‌ها است. راه حل پایتونی، استفاده از ‍properties است.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "ceb668e5-75a1-4e19-a1be-8bed99235b76",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Second:\n",
    "\n",
    "    def __init__(self, x):\n",
    "        self.x = x\n",
    "\n",
    "    @property\n",
    "    def x(self):\n",
    "        print(\"---> getter <---\")\n",
    "        return self.__x\n",
    "\n",
    "    @x.setter\n",
    "    def x(self, x):\n",
    "        print(\"---> setter <---\")\n",
    "        if x < 0:\n",
    "            self.__x = 0\n",
    "        elif x > 1000:\n",
    "            self.__x = 1000\n",
    "        else:\n",
    "            self.__x = x\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92f0b2d9-475a-4cff-a0c0-9fcc3349dbaa",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "setter:این متد به عنوان تنظیم‌کننده (setter) برای یک متغیر عمل می‌کند. قبل از آن باید از @varible_name.setter استفاده شود و زمانی که مقدار به متغیر ‍assign شود صدا زده می‌شود.\n",
    "<br>\n",
    "‏property:این متد کاملا مشابه getter برای یک متغیر عمل می‌کند. فقط باید قبل از آن از @property استفاده شود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "2d4663a6-76f0-4db3-a242-adde27ac34ba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---> setter <---\n",
      "---> getter <---\n",
      "1000\n",
      "---> setter <---\n",
      "---> getter <---\n",
      "0\n",
      "---> setter <---\n",
      "---> getter <---\n",
      "17\n",
      "---> setter <---\n",
      "---> getter <---\n",
      "25\n"
     ]
    }
   ],
   "source": [
    "\n",
    "obj1 = Second(1001)\n",
    "print(obj1.x)\n",
    "\n",
    "\n",
    "\n",
    "obj2 = Second(-73)\n",
    "print(obj2.x)\n",
    "\n",
    "\n",
    "\n",
    "obj3 = Second(17)\n",
    "print(obj3.x)\n",
    "\n",
    "\n",
    "obj3.x = 25\n",
    "print(obj3.x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42480d2c-74db-4368-919a-81e3354c84b3",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "شاید به اشتباه فکر کنید که هر attribute‍ ، چه public و چه private نیاز به property‍ (یا getter و setter ) نظیر دارد.\n",
    "<br>\n",
    "اما حتی در زبان های شئ‌گرای دیگر نیز این ایده‌ی درستی نیست. دلیل اصلی، این است که بسیاری از attribute ها صرفا کاربرد داخلی دارند و یا نیازی به بررسی شرایطی مانند چیزی که در بالا گفته شده ندارند. استفاده از این متدها در این موارد تنها خوانایی کد را کاهش می‌دهد.\n",
    "<br>\n",
    "برای مثال در کد زیر دو متغیر __potential_physical و ‍‍‍‍__potential_psychic فقط استفاده‌ی داخلی دارند. هم‌چنین نشان داده شده که یک مقدار یک property می‌تواند از سایر ویژگی‌ها استنباط شود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "fa49868b-5b22-4ff3-b970-6dc3f0be0b77",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Seems to be okay!\n",
      "I feel bad!\n"
     ]
    }
   ],
   "source": [
    "class Robot:\n",
    "\n",
    "    def __init__(self, name, build_year, lk = 0.5, lp = 0.5 ):\n",
    "        self.name = name\n",
    "        self.build_year = build_year\n",
    "        self.__potential_physical = lk  # private attribute\n",
    "        self.__potential_psychic = lp # private attribute\n",
    "\n",
    "    @property\n",
    "    def condition(self):\n",
    "        s = self.__potential_physical + self.__potential_psychic\n",
    "        if s <= -1:\n",
    "            return \"I feel miserable!\"\n",
    "        elif s <= 0:\n",
    "            return \"I feel bad!\"\n",
    "        elif s <= 0.5:\n",
    "            return \"Could be worse!\"\n",
    "        elif s <= 1:\n",
    "            return \"Seems to be okay!\"\n",
    "        else:\n",
    "            return \"Great!\" \n",
    "\n",
    "Wall_E= Robot(\"Wall-E\", 1979, 0.2, 0.4 )\n",
    "Hal = Robot(\"Hal\", 1993, -0.4, 0.3)\n",
    "print(Wall_E.condition)\n",
    "print(Hal.condition)\n",
    "\n",
    "# output\n",
    "# Seems to be okay!\n",
    "# I feel bad!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e1ea189-baef-4b25-97b0-74bf7a3c4a55",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "در انتها برای اینکه ابهامات در مورد public/private attributeها و سایر موارد تا حد امکان برطرف شود، مراحل زیر را طی کنید:\n",
    "<br>\n",
    "اول به این سوال پاسخ بدهید که آیا استفاده‌کنندگان کلاس نیاز به دسترسی به مقدار متغیر دارند؟\n",
    "    <br>\n",
    "اگر خیر، بهتر است که متغیرها به صورت private تعریف شوند.\n",
    "    <br>\n",
    "اگر بله، باید متغیرها به صورت public تعریف شوند.\n",
    "    <br>\n",
    "اگر و فقط اگر مجبور به انجام برخی بررسی‌ها یا تغییر شکل داده‌ها باشیم از @property استفاده می‌کنیم (البته هم‌چنان می‌توان از آن برای ایجاد متغیرهای استنباط‌شده استفاده کرد.).\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94b20ddd-ad48-45d1-ba78-643ea48aea32",
   "metadata": {},
   "source": [
    "#### 2.10.5. Instrospection"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c18fca10-a9dd-4e24-a35a-1a93d3b9bd8e",
   "metadata": {},
   "source": [
    "##### 2.10.5.1. \"dir\" function"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7899916-46f3-4ebb-8aa4-ed98c3f9f6dd",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "این تابع مهم‌ترین و ابتدایی‌ترین تابع برای introspection است که به عنوان ورودی یک شی می‌گیرد و لیست خصوصیات (attributes) شی داده شده را برمی‌گرداند (توجه کنید که در پایتون همه چیز حتی تابع‌ها شی هستند و از کلاسobject ارث برده‌اند).\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "e4170c9b-c0a0-4827-b70a-e760db9c1729",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__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__', 'get_age', 'name']\n"
     ]
    }
   ],
   "source": [
    "class Person():\n",
    "    def get_age(self):\n",
    "            pass\n",
    "    name = 'Saeid'\n",
    "    pass\n",
    "person = Person()\n",
    "print(dir(person))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "556801c6-99d1-48ad-a3a8-16b79af687d1",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "دقت کنید که در خروجی تابع dir تعداد زیادی خصوصیت‌ وجود دارد که به صورت پیش‌فرض در کلاس object وجود دارد و همه اشیا با ارث‌بری از کلاس object این خصوصیات را دارا هستند (مانند خروجی‌های چاپ شده در بالا).\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aac1a9ac-fe2a-453c-a060-4df87e4dd301",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "اگر تابع dir را بدون ورودی صدا کنید، لیست متغیر‌های محلی محدود‌ه‌ای که در آن فراخوانده می‌شود را خروجی می‌دهد.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "45783f50-92d6-4e59-96df-c83986ba7a9f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['number_2']\n"
     ]
    }
   ],
   "source": [
    "number = 100\n",
    "def func():\n",
    "    number_2 = 200\n",
    "    print(dir())\n",
    "    pass\n",
    "func()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d73ddbf3-ce99-48ca-baba-1508e5bed081",
   "metadata": {},
   "source": [
    "##### 2.10.5.2. \"type()\" function"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f0e2ac2-f970-408e-8604-031520d581b8",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "این تابع به دو شکل قابل استفاده است.\n",
    "<br>\n",
    "در شکل اول، به آن یک شی ورودی داده شده و تابع جنس (type) آن را در همان لحظه از اجرای برنامه بر‌می‌گرداند.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f33e9509-5e25-4ddd-a1a5-974972bd230c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'list'>\n",
      "<class 'function'>\n",
      "<class 'type'>\n"
     ]
    }
   ],
   "source": [
    "a = 100\n",
    "print(type(a))\n",
    "\n",
    "a = [1, 2, 3]\n",
    "print(type(a))\n",
    "\n",
    "def func():\n",
    "    pass\n",
    "\n",
    "print(type(func))\n",
    "\n",
    "print(type(type))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1de84035-77e9-4b41-8a90-86e8f765f1a9",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "دقت کنید که جنس a در هنگام اجرای برنامه عوض شده و تابع type جنس آن را دو مقدار متفاوت برمی‌گرداند.\n",
    "<br>\n",
    "تابع type در اصل یک کلاس است که توانایی صداشدن (calling) دارد\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "668b7f72-0121-40e0-adbc-663d94d333e3",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "شکل دوم این تابع برای ساخت یک جنس (type) جدید به کار می‌رود.\n",
    "<br>\n",
    "برای این کار به ترتیب سه آرگومان زیر را ورودی می‌گیرد:\n",
    "<br>\n",
    "نام: یک رشته که نام جنس جدیدی را که می‌خواهیم بسازیم مشخص می‌کند.\n",
    "    <br>\n",
    "پایه‌ها‌ (bases): یک چندتایی که شامل کلاس‌هایی است که از آن‌ها ارث می‌برد.\n",
    "    <br>\n",
    "ویژگی‌ها: یک لغت‌نامه که خصوصیات آن جنس را مشخص می‌کند. هر کلید آن، یک ویژگی و هر مقدار، مقدار پیش‌فرض آن ویژگی را مشخص می‌کند.\n",
    "    <br>\n",
    "در نهایت هم type جدید با خصوصیات داده شده را خروجی می‌دهد.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "c4e95d83-bf8e-4565-bf7e-8010e7d13011",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "130\n",
      "default\n",
      "amir\n",
      "<class 'type'>\n",
      "<class '__main__.MyNewType'>\n"
     ]
    }
   ],
   "source": [
    "def set_name(self, name):\n",
    "    self.name = name\n",
    "\n",
    "Kid = type('MyNewType', (object,), {'age': 4, 'height': 130, 'name': 'default', 'set_name': set_name})\n",
    "kid = Kid()\n",
    "print(kid.age)\n",
    "\n",
    "print(kid.height)\n",
    "\n",
    "print(kid.name)\n",
    "\n",
    "kid.set_name('amir')\n",
    "print(kid.name)\n",
    "print(type(Kid))\n",
    "print(type(kid))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afe0f9ad-d4ad-4a3e-8944-ad4a41ee5c5e",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "جنس Kid دارای سازنده پیش‌فرض است زیرا از object ارث برده است.\n",
    "<br>\n",
    "دقت کنید که با کمک لغت‌نامه‌ی ویژگی‌ها می‌توان حتی یک تابع را به عنوان خصوصیات جنس ساخته شده قرار داد.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edfcb81f-afb4-4829-88cb-f069fd34b685",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "هم‌چنین جنس جدید، همه ویژگی‌هایی که پدرهاش دارند را حفظ می‌کند:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "55010676-d154-4ecd-8bb6-be5b09fb9ae7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "8\n",
      "['__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__', 'age', 'height', 'name']\n"
     ]
    }
   ],
   "source": [
    "class Person():\n",
    "    name = ''\n",
    "    age = 8\n",
    "    pass\n",
    "\n",
    "Kid = type('Kid', (Person,), {'height': 130})\n",
    "kid = Kid()\n",
    "\n",
    "print(kid.name)\n",
    "print(kid.age)\n",
    "print(dir(kid))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb98f4a0-37ea-4c34-a0f8-f39eccc13594",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "در این‌جا می‌بینید که ‍‍Kid دو ویژگی ‍‍name و age را هم دارد.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f68cc747-4216-4d6d-a5fb-eee2e50784ac",
   "metadata": {},
   "source": [
    "##### 2.10.5.3. Inheritance-Introseption function"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4929f05-2e55-41ab-9508-eca519003690",
   "metadata": {},
   "source": [
    "###### 2.10.5.3.1. \"isinstance()\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5abe3222-3fa2-4e43-962a-b3feaf42c8d0",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "تابع isinstance() یک شی و یک کلاس (یا چندین کلاس) یا یک تایپ (type) (یا چندین تایپ) ورودی می‌گیرد و در جواب متغیری منطقی بر می‌گرداند که نشان می‌دهد این شئ، یک عضو از آن کلاس هست یا نه.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1c49b48f-1051-423d-ae1b-b36814ab8943",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "class Animal():\n",
    "    def __init__(self, name, type):\n",
    "        self.name = name\n",
    "        self.type = type\n",
    "        pass\n",
    "    pass\n",
    "class Fox(Animal):\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        self.type = 'Fox'\n",
    "\n",
    "class Person():\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "fox = Fox('Alex')\n",
    "print(isinstance(fox, Fox))\n",
    "\n",
    "print(isinstance(fox, Animal))\n",
    "\n",
    "print(isinstance(fox, Person))\n",
    "\n",
    "print(isinstance(fox, (Animal, Person)))\n",
    "\n",
    "print(isinstance(fox, (list, Person)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "12067b6f-9ba9-41d0-b902-3eafe0a052fb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(isinstance(2, int))\n",
    "\n",
    "print(isinstance(2, str))\n",
    "\n",
    "print(isinstance(2, (str, list, int, float)))\n",
    "\n",
    "print(isinstance('Hello', int))\n",
    "\n",
    "print(isinstance(\"Hello\", (float, str, int, list, dict, tuple)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca4148fd-848d-4a2d-b3a9-2a6582824b1c",
   "metadata": {},
   "source": [
    "###### 2.10.5.3.2. \"issubclass()\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59a43fdd-cd53-494b-8b96-270e43822962",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "همین‌طور تابع issubclass() دو کلاس ورودی می‌گیرد و در جواب متغیر منطقی بر می گرداند که نشان می‌دهد کلاس اول از فرزندان کلاس دوم هست یا نه.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b8c27d33-340a-4e1f-b4dd-9e228f4fc019",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n",
      "False\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "class Animal():\n",
    "    def __init__(self, name, type):\n",
    "        self.name = name\n",
    "        self.type = type\n",
    "\n",
    "class Bird(Animal):\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        self.type = 'Bird'\n",
    "\n",
    "class Owl(Bird):\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        self.type = 'Bird'\n",
    "        self.bird_type = 'Owl'\n",
    "\n",
    "class Person():\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "print(issubclass(Bird, Animal))\n",
    "\n",
    "print(issubclass(Owl, Animal))\n",
    "\n",
    "print(issubclass(Animal, Owl))\n",
    "\n",
    "print(issubclass(Person, Animal))\n",
    "\n",
    "print(issubclass(Animal, object))\n",
    "\n",
    "print(issubclass(Owl, (Animal, Person)))\n",
    "\n",
    "print(issubclass(Bird, (Person, list, Owl)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a4108ea-f529-4af4-b3cf-3cd9ca61cd97",
   "metadata": {},
   "source": [
    "#### 2.10.6. Reflection"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c5702c2-251d-4ff2-8ea1-ac37eee0a39a",
   "metadata": {},
   "source": [
    "methods also in this topic are included in attributes."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf000dc5-ecdc-4e86-a08c-9cf6233e4fd4",
   "metadata": {},
   "source": [
    "##### 2.10.6.1. \"getattr()\" function"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f26e8048-ba3d-4b09-9737-feb647729bbc",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "این تابع دو آرگومان object و name را ورودی می‌گیرد و object.name را خروجی می‌دهد. برای مثال:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "11e34eb4-e179-43fb-9e0f-ae211632c9a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " name\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "amir\n"
     ]
    }
   ],
   "source": [
    "class A():\n",
    "    def __init__(self, age, name):\n",
    "        self.age = age\n",
    "        self.name = name\n",
    "        pass\n",
    "    pass\n",
    "\n",
    "a = A(12, 'amir')\n",
    "print(getattr(a, 'age'))\n",
    "\n",
    "s = input()\n",
    "print(getattr(a, s))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1c2cd6f-5fb2-4dc4-9893-6ac4c851f373",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "در اصل تابع getattr، تابع‌ object.__getattr__() را صدا می‌کند که در کلاس object به صورت پیش‌فرض تعریف شده است.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7897659b-67dc-4d7d-82fc-ef65705ff763",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "این تابع دارای یک آرگومان غیرضروری (optional) به نام پیش‌فرض یا default است که اگر شی داده شده خصوصیت مورد نظر را نداشت این مقدار برگردانده می‌شود (در صورتی که این ورودی داده نشود و خصوصیت وجود نداشته باشد، برنامه یک استثنا پرتاب می‌کند).\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "3ad1c875-91d6-45b0-9d63-3dfa1fe57241",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "a = 0\n",
    "print(getattr(a, 'age', 12))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ea55e8c-da5c-48a3-b566-3ccad96c1d02",
   "metadata": {},
   "source": [
    "##### 2.10.6.2. \"setattr()\" function"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f1465a8-aa6f-4405-8506-b5ba20925d3d",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "این تابع سه آرگومان دارد که اولی یک شی، دومی نام خصوصیت و سومی مقدار آن را ورودی می‌گیرد و در شی داده شده مقدار خصوصیت داده شده را برابر با مقدار مورد نظر قرار می‌دهد.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "16076294-2e02-4fe0-b28b-3afe37e48dbc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "amir , 12\n",
      "15\n"
     ]
    }
   ],
   "source": [
    "class A():\n",
    "    def __init__ (self, age):\n",
    "        self.age = age\n",
    "        pass\n",
    "    def set_age(self, age):\n",
    "        self.age = age\n",
    "        pass\n",
    "    pass\n",
    "a = A(10)\n",
    "setattr(a, 'age', 12) # changing attribute\n",
    "setattr(a, 'name', 'amir') # making attribute\n",
    "\n",
    "print(a.name + \" , \" + str(a.age))\n",
    "setattr(a, \"set_age\", 15)\n",
    "print(a.set_age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "59116dc0-5031-4496-a888-c9a1ffd96aaa",
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'A' object has no attribute 'name'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_15592/3210673201.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mA\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m14\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mb\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: 'A' object has no attribute 'name'"
     ]
    }
   ],
   "source": [
    "b = A(14)\n",
    "print(b.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4da9dd1c-ea7b-4257-b26a-6a7865b6bafa",
   "metadata": {},
   "source": [
    "----------------------------------\n",
    "- __تعریف توابع به صورت پویا__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "98347f01-b558-46dd-8a32-45c84f5df5bf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "amir\n",
      "12\n",
      "A\n"
     ]
    }
   ],
   "source": [
    "class A():\n",
    "    def __init__(self):\n",
    "        self.attrs = {'name': 'amir', 'age': 12, 'grade': 'A'}\n",
    "\n",
    "    def __getattr__(self, attr):\n",
    "\n",
    "        if attr in self.attrs:\n",
    "            return self.attrs[attr]\n",
    "\n",
    "        def f():\n",
    "            return getattr(self, attr[4:])\n",
    "\n",
    "        return f\n",
    "    pass\n",
    "\n",
    "\n",
    "a = A()\n",
    "\n",
    "print(a.get_name())\n",
    "print(a.get_age())\n",
    "print(a.get_grade())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1319c1f5-8d71-467e-95db-b739ed380dc7",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "دقت کنید که . و ‍getattr() تابع __getattr__() را صدا می‌کنند. با over ride کردن این تابع توانستیم توابع گیرنده (getter) کلاس را بسازیم.\n",
    "    <br>\n",
    "    در واقع در کد بالا،‌ اگر ویژگی attr در میان ویژگی‌ها وجود داشت مقدار آن برگردانده می‌شود و در غیر این صورت ۴ حرف اول آن که برابر با get_ است حذف می‌شود و تابعی که آن مقدار را برمی‌گرداند، برگردانده می‌شود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a71cb40b-25f0-423a-947a-73febf241de6",
   "metadata": {},
   "source": [
    "------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6240689d-c929-4b0c-94ea-6cd8396858d5",
   "metadata": {},
   "source": [
    "#### 2.10.7. Dunder Methods (Magic Methods)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "402814fc-15b0-451b-9529-8582904acfcb",
   "metadata": {},
   "source": [
    "<div>\n",
    "Dunder Methods are methods with the name format: __methodname__\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b12e1c82-3469-4677-9a68-190a41ad830a",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "کلاس زیر را در نظر بگیرید:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f8a1f27f-4491-4512-9b2e-b69370b2bc8d",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Movie:\n",
    "    def __init__(self, name, release_year):\n",
    "        self.name = name\n",
    "        self.release_year = release_year"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c40bc8cb-c9cd-49c4-8176-f78fbc09a770",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__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__', 'name', 'release_year']\n"
     ]
    }
   ],
   "source": [
    "favorite_movie = Movie('Fight Club', 1999)\n",
    "print(dir(favorite_movie))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e989a0ac-cc9c-49ac-b3f6-5c41c856575a",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "همانطور که مشاهده می‌کنید، به غیر از دو ویژگی آخر لیست که ما به این شیء اختصاص دادیم بقیه عناصر همگی اسامی داندر متدهایی هستند که به واسطه ارث‌بری از کلاس object وجود دارند؛\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36bc33c6-1a96-4253-abcb-9a1bc077f061",
   "metadata": {},
   "source": [
    "<h5> 2.10.7.1. __str__ </h5>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "766ca773-8381-4e55-bfd7-f6b236a10752",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "اگر شیء favorite_movie را چاپ کنیم خروجی چه خواهد بود؟\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "df8ca392-3c5a-4180-9930-d2f1af1a1ca9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Movie object at 0x000001C5C5C0BF40>\n"
     ]
    }
   ],
   "source": [
    "print(favorite_movie)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6dab2c01-0481-4d7e-8cec-171987ed686b",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "شاید برای بسیاری از افراد این خروجی که به صورت پیش‌فرض برای همه اشیاء اعمال شده است، خوشایند نباشد. به عنوان مثال برای اشیاء کلاس Movie می‌خواهیم که با چاپ کردن آن‌ها اسم فیلم را در خروجی ببینیم. خوشبختانه با استفاده از جادوی داندر متدها می‌توانیم این مشکل را حل کنیم:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "151d63ce-0dd6-4a31-8d80-eb98b4664a2d",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Movie:\n",
    "    def __init__(self, name, release_year):\n",
    "        self.name = name\n",
    "        self.release_year = release_year\n",
    "\n",
    "    def __str__(self):\n",
    "        return self.name"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d877318-a401-48bc-9122-f46f968c9703",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "همانطور که مشاهده می‌کنید متد __str__ را به شکلی بازنویسی کردیم که اگر روی هر شیء از کلاس Movie فراخوانی شود نام آن شیء را خروجی دهد.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "92c8a9ca-2373-43ca-9d20-1d3e7f536672",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fight Club\n",
      "Fight Club\n"
     ]
    }
   ],
   "source": [
    "favorite_movie = Movie('Fight Club', 1999)\n",
    "favorite_movie.__str__()\n",
    "\n",
    "print(str(favorite_movie))\n",
    "\n",
    "print(favorite_movie)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c271db57-6bd3-4810-b462-e3b2e2cd5813",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "در واقع تابع print هر شیئی که به آن ورودی داده شود، خروجی تابع str آن را چاپ می‌کند و تابع str هم کاملا طبق پیاده‌سازی داندر متد __str__ عمل می‌کند. یعنی وقتی str(favorite_movie) را اجرا کنیم، خروجی favorite_movie.__str__() خروج داده می‌شود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1db68399-77b9-41da-b86d-d1ed04512914",
   "metadata": {},
   "source": [
    "##### 2.10.7.2. Overloading of operators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9d160ab-5199-42c7-b1f3-1748255accc9",
   "metadata": {},
   "source": [
    "<h6> 2.10.7.2.1. __lt__ </h6>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "9966e506-14a5-4c56-8156-7bb666582342",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Movie:\n",
    "    def __init__(self, name, release_year):\n",
    "        self.name = name\n",
    "        self.release_year = release_year\n",
    "\n",
    "    def __str__(self):\n",
    "        return self.name\n",
    "\n",
    "    def __lt__(self, other_object):\n",
    "        return self.release_year < other_object.release_year "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ffe5e5eb-353c-4cb4-b7cf-84b010a41c52",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "همانطور که مشاهده می‌کنید متد __lt__ را به شکلی بازنویسی کردیم که عملگر <، برای مقایسه سال انتشار فیلم‌ها به کار گرفته شود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "raw",
   "id": "14f9842d-4702-4630-a3d0-3a89f97254e0",
   "metadata": {},
   "source": [
    ">>> hangover = Movie('Hangover', 2009)\n",
    ">>> se7en = Movie('ُSe7en', 1995)\n",
    ">>> se7en.__lt__(hangover)\n",
    "True\n",
    ">>> se7en < hangover\n",
    "True\n",
    ">>> hangover.__lt__(se7en)\n",
    "False\n",
    ">>> hangover < se7en\n",
    "False"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de1a9237-050f-4e58-a059-5d46ab71eda8",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "وقتی se7en < hangover را اجرا کنیم، خروجی se7en.__lt__(hangover) خروج داده می‌شود.\n",
    "<br>\n",
    "به همین شکل می‌توانیم عملگرهای مقایسه‌ای دیگر را هم با استفاده از داندر مخصوص آن‌ها برای کلاس خود تعریف کنیم:\n",
    "    <br>\n",
    "    <table dir=\"auto\" class=\"ui unstackable table\">\n",
    "<thead>\n",
    "<tr>\n",
    "<th align=\"center\">نام عملگر</th>\n",
    "<th align=\"center\">عبارت</th>\n",
    "<th align=\"center\">داندر متد</th>\n",
    "</tr>\n",
    "</thead>\n",
    "<tbody><tr>\n",
    "<td align=\"center\">کوچک‌تر</td>\n",
    "<td align=\"center\"><code dir=\"ltr\">a &lt; b</code></td>\n",
    "<td align=\"center\"><code dir=\"ltr\">__lt__</code></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td align=\"center\">بزرگ‌تر</td>\n",
    "<td align=\"center\"><code dir=\"ltr\">a &gt; b</code></td>\n",
    "<td align=\"center\"><code dir=\"ltr\">__gt__</code></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td align=\"center\">کوچک‌تر یا مساوی</td>\n",
    "<td align=\"center\"><code dir=\"ltr\">a &lt;= b</code></td>\n",
    "<td align=\"center\"><code dir=\"ltr\">__le__</code></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td align=\"center\">بزرگ‌تر یا مساوی</td>\n",
    "<td align=\"center\"><code dir=\"ltr\">a &gt;= b</code></td>\n",
    "<td align=\"center\"><code dir=\"ltr\">__ge__</code></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td align=\"center\">مساوی</td>\n",
    "<td align=\"center\"><code dir=\"ltr\">a == b</code></td>\n",
    "<td align=\"center\"><code dir=\"ltr\">__eq__</code></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td align=\"center\">نامساوی</td>\n",
    "<td align=\"center\"><code dir=\"ltr\">a != b</code></td>\n",
    "<td align=\"center\"><code dir=\"ltr\">__ne__</code></td>\n",
    "</tr>\n",
    "</tbody></table>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6fe4c49-c7f0-49f7-8d17-0eb53fddc8eb",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "می‌دانیم که اگر بعد از اسم تابع یا متد () بگذاریم، فراخوانی انجام می‌شود. طبق روال قبلی، این سناریو را برای شیئی از کلاس Movie تصور کنید و نتیجه را پیش‌بینی کنید.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "raw",
   "id": "8c5257a9-d831-4d87-bc16-6616238d034d",
   "metadata": {},
   "source": [
    ">>> scarface = Movie('Scarface', 1983)\n",
    ">>> scarface()\n",
    "Traceback (most recent call last):\n",
    "  File \"<stdin>\", line 1, in <module>\n",
    "TypeError: 'Movie' object is not callable"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0dfa5af5-f7e5-4939-8bf5-9fd4696cd919",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "همانطور که می‌بینید برنامه متوقف می‌شود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "194f801f-c936-420f-bc6e-b74442ae31ab",
   "metadata": {},
   "source": [
    "<h6> 2.10.7.2.2. __add__ </h6>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "253b5e34-f6dc-49d9-ac31-07dbfd84b37a",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    همانطور که می‌دانید در پایتون اگر عملگر + را:\n",
    "<ul dir=\"auto\">\n",
    "<li>بین دو <strong>عدد</strong> به کار ببریم، در خروجی جمع ریاضی دو عدد را نشان می‌دهد.</li>\n",
    "<li>بین دو <strong>رشته</strong> به کار ببریم، در خروجی رشته اول را به رشته دوم می‌چسباند.</li>\n",
    "<li>بین دو <strong>لیست</strong> به کار ببریم، در خروجی عناصر لیست دوم را در ادامه عناصر لیست اول قرار می‌دهد.</li>\n",
    "</ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5599831-f284-4913-8db1-82aab11bfc37",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "این تفاوت عملکرد برای اشیاء مختلف، به دلیل پیاده‌سازی‌های متفاوت داندر متد __add__ می‌باشد. برای مثال کلاس زیر را در نظر بگیرید:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2addbeb9-494e-4802-843a-91fa6eb1ccde",
   "metadata": {},
   "outputs": [],
   "source": [
    "class FootballTeam:\n",
    "    def __init__(self, name, cups_number):\n",
    "        self.name = name\n",
    "        self.cups_number = cups_number\n",
    "\n",
    "    def __add__(self, other_object):\n",
    "        return self.cups_number + other_object.cups_number"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc8bfdaf-e4f2-4912-877a-7461868360be",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "در حالت عادی وقتی عملگر + بین دو شیء از کلاس FootballTeam قرار می‌گیرد، برنامه متوقف می‌شود به دلیل اینکه نمی‌داند دقیقا چه چیزی را باید جمع بزند! ما با تعریف داندر متد __add__ وظیفه عملگر + را مشخص کرده‌ایم. پس انتظار داریم بعد از تعریف این متد، عملگر + تعداد جام‌های قهرمانی تیم‌ها را با یکدیگر جمع بزند:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "raw",
   "id": "da0c6186-e40b-4c13-82d8-9b614d6ba3be",
   "metadata": {},
   "source": [
    ">>> bayern_munich = FootballTeam('FC Bayern Munich', 6)\n",
    ">>> barcelona = FootballTeam('FC Barcelona', 5)\n",
    ">>> bayern_munich + barcelona\n",
    "11"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a503218a-23fe-4b35-8139-846271efe73e",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "به همین شکل می‌توانیم عملگرهای ریاضی و منطقی دیگر را هم با استفاده از داندر مخصوص آن‌ها، برای کلاس خود تعریف کنیم:\n",
    "    <br>\n",
    "    <table dir=\"auto\" class=\"ui unstackable table\">\n",
    "<thead>\n",
    "<tr>\n",
    "<th align=\"center\">نام عملگر</th>\n",
    "<th align=\"center\">عبارت</th>\n",
    "<th align=\"center\">داندر متد</th>\n",
    "</tr>\n",
    "</thead>\n",
    "<tbody><tr>\n",
    "<td align=\"center\">جمع</td>\n",
    "<td align=\"center\"><code dir=\"ltr\">a + b</code></td>\n",
    "<td align=\"center\"><code dir=\"ltr\">__add__</code></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td align=\"center\">تفریق</td>\n",
    "<td align=\"center\"><code dir=\"ltr\">a - b</code></td>\n",
    "<td align=\"center\"><code dir=\"ltr\">__sub__</code></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td align=\"center\">ضرب</td>\n",
    "<td align=\"center\"><code dir=\"ltr\">a * b</code></td>\n",
    "<td align=\"center\"><code dir=\"ltr\">__mul__</code></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td align=\"center\">تقسیم اعشاری</td>\n",
    "<td align=\"center\"><code dir=\"ltr\">a / b</code></td>\n",
    "<td align=\"center\"><code dir=\"ltr\">__truediv__</code></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td align=\"center\">تقسیم صحیح</td>\n",
    "<td align=\"center\"><code dir=\"ltr\">a // b</code></td>\n",
    "<td align=\"center\"><code dir=\"ltr\">__floordiv__</code></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td align=\"center\">باقی‌مانده</td>\n",
    "<td align=\"center\"><code dir=\"ltr\">a % b</code></td>\n",
    "<td align=\"center\"><code dir=\"ltr\">__mod__</code></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td align=\"center\">توان</td>\n",
    "<td align=\"center\"><code dir=\"ltr\">a ** b</code></td>\n",
    "<td align=\"center\"><code dir=\"ltr\">__pow__</code></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td align=\"center\">شیفت چپ</td>\n",
    "<td align=\"center\"><code dir=\"ltr\">a &lt;&lt; b</code></td>\n",
    "<td align=\"center\"><code dir=\"ltr\">__lshift__</code></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td align=\"center\">شیفت راست</td>\n",
    "<td align=\"center\"><code dir=\"ltr\">a &gt;&gt; b</code></td>\n",
    "<td align=\"center\"><code dir=\"ltr\">__rshift__</code></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td align=\"center\">AND</td>\n",
    "<td align=\"center\"><code dir=\"ltr\">a &amp; b</code></td>\n",
    "<td align=\"center\"><code dir=\"ltr\">__and__</code></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td align=\"center\">OR</td>\n",
    "<td align=\"center\"><code dir=\"ltr\">a ا b</code></td>\n",
    "<td align=\"center\"><code dir=\"ltr\">__or__</code></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td align=\"center\">XOR</td>\n",
    "<td align=\"center\"><code dir=\"ltr\">a ^ b</code></td>\n",
    "<td align=\"center\"><code dir=\"ltr\">__xor__</code></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td align=\"center\">NOT</td>\n",
    "<td align=\"center\"><code dir=\"ltr\">~a</code></td>\n",
    "<td align=\"center\"><code dir=\"ltr\">__invert__</code></td>\n",
    "</tr>\n",
    "</tbody></table>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14350e80-d0ec-4a06-9f42-d69522c85741",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6766d4fb-fa1d-482b-9f3f-497c6b781832",
   "metadata": {},
   "source": [
    "<h5> 2.10.7.3. __call__ </h5>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b1c9904-7717-4bba-b89c-b4adcde937d6",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "می‌دانیم که اگر بعد از اسم تابع یا متد () بگذاریم، فراخوانی انجام می‌شود. طبق روال قبلی، این سناریو را برای شیئی از کلاس Movie تصور کنید و نتیجه را پیش‌بینی کنید.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "a15268a8-ba25-4fb6-a208-a7ef2c02e177",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'Movie' object is not callable",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_7528/2460191143.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mscarface\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mMovie\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Scarface'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m1983\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mscarface\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'Movie' object is not callable"
     ]
    }
   ],
   "source": [
    "scarface = Movie('Scarface', 1983)\n",
    "scarface()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0eee7120-dbcd-4699-bc65-4fe3cd312574",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "همانطور که می‌بینید برنامه متوقف می‌شود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94439fa5-b104-4bb1-8754-1935d2fa8bc6",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    در پایتون فقط توابع نیستند که می‌توانند صدا شوند. هر شیئی که تابع __call__() در آن تعریف شده باشد، می‌تواند به صورت obj() صدا شود.\n",
    "    <br>\n",
    "داندر متد __call__ تعیین می‌کند که با قرار گرفتن () بعد از یک شیء، چه عملی انجام شود. اکنون اگر داندر متد __call__ را بدین صورت بازنویسی کنیم:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "9f370c2c-426d-484b-b783-da5decc5b50c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "400"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class A:\n",
    "    def __call__(self, x):\n",
    "        return x**2\n",
    "        pass\n",
    "    pass\n",
    "\n",
    "\n",
    "a = A()\n",
    "a(20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "50f41b76-9720-41b7-955f-b6c4c8b67558",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Movie:\n",
    "    def __init__(self, name, release_year):\n",
    "        self.name = name\n",
    "        self.release_year = release_year\n",
    "\n",
    "    def __str__(self):\n",
    "        return self.name\n",
    "\n",
    "    def __lt__(self, other_object):\n",
    "        return self.release_year < other_object.release_year \n",
    "\n",
    "    def __call__(self):\n",
    "        return 'Say Hello to My Little Friend!😈'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "782fbef4-75cc-43be-bca6-805731cf410c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Say Hello to My Little Friend!😈\n",
      "Say Hello to My Little Friend!😈\n"
     ]
    }
   ],
   "source": [
    "scarface = Movie('Scarface', 1983)\n",
    "\n",
    "print(scarface.__call__())\n",
    "\n",
    "print(scarface())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6da18550-c50e-46fe-95b8-781cca9336c1",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "وقتی scarface() را اجرا کنیم، خروجی scarface.__call__() خروج داده می‌شود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12c6a275-bcc4-44de-a940-bdd98f245be3",
   "metadata": {},
   "source": [
    "<h5> 2.10.7.4. __len__ </h5>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a4b8d9e-d817-459f-ac27-cc712ed095f2",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "قطعا تا به حال بارها از تابع len() استفاده کرده‌اید. رفتار این تابع به نحوه پیاده‌سازی داندر متد __len__ بستگی دارد. برای مثال اگر بخواهیم هنگام استفاده از این تابع برای لیست‌ها تعداد عناصر یکتا را نشان دهد می‌توانیم بدین شکل عمل کنیم:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "5fe9d55e-c8d1-455f-aebd-e3e624e51779",
   "metadata": {},
   "outputs": [],
   "source": [
    "class CustomList(list):\n",
    "    def __len__(self):\n",
    "        return len(set(self))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ad9071b-8705-4368-b1c1-d66401ecdf5e",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "در نتیجه تابع len در نشان دادن طول لیست (CustomList) فقط عناصر یکتا را به حساب می‌آورد:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "27567b5b-40a2-49c8-9d70-7150772ff3f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "my_list = CustomList([1, 1, 1, 1, 1, 684])\n",
    "\n",
    "print(my_list.__len__())\n",
    "\n",
    "print(len(my_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af688dcf-3cc5-4d0a-8a83-0710ace008c0",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "وقتی len(my_list) را اجرا کنیم، خروجی my_list.__len() خروج داده می‌شود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5af4e284-122a-4cd3-90e3-88a790126a37",
   "metadata": {},
   "source": [
    "<h5> 2.10.7.5. __iter__ and __next__ </h5>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "efe85b2f-210a-4238-9c54-630d4c3c3ad6",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "اگر دقت کرده باشید اکثر اشیا‌یی که شامل چند شئ دیگر درون خود هستند (container objects) مانند لیست، رشته، لغت‌نامه، چندتایی و ... می‌توانند توسط دستور for پیمایش شوند.\n",
    "<br>\n",
    "دستور for برای پیمایش کردن یک شئ، تابع iter() آن را صدا می‌زند. این تابع باید یک پیمایش‌گر (iterator) برگرداند. این پیمایش‌گر باید یک تابع __next__() داشته باشد که با صدا کردن آن، پیمایش‌گر یک واحد حرکت کند. در نهایت اگر به انتها رسید یک خطای StopIteration‍‍ را صدا کند. درضمن می‌توان با تابع next(a) تابع a.__next__() را صدا کرد. برای درک بهتر این موضوع به مثال زیر دقت کنید.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "0f773032-2efa-4521-a747-6bd71680e616",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<list_iterator object at 0x000001C5C5BF2100>\n",
      "1\n",
      "2\n",
      "4\n"
     ]
    },
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_7528/3742387904.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      9\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mit\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     10\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 11\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mit\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "ls = [1, 2, 4]\n",
    "it = iter(ls)\n",
    "print(it)\n",
    "\n",
    "print(next(it))\n",
    "\n",
    "print(next(it))\n",
    "\n",
    "print(next(it))\n",
    "\n",
    "print(next(it))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25212ba3-ca2d-4de5-b728-95d10ef1ed6a",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    با وقوع خطای StopIteration پیمایش متوقف می شود .\n",
    "    <br>\n",
    "حال یک کلاس تعریف می‌کنیم که قابلیت پیمایش شدن دارد و اعضای یک لیست را به صورت تصادفی می‌چیند.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "dc42ac63-37a4-44e4-8d7c-a92e1357578c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 6\n",
      "2 1 3 5 6 4\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "class RandomShuffle:\n",
    "    def __init__(self, data):\n",
    "        self.data = data\n",
    "\n",
    "    def __iter__(self):\n",
    "        return self\n",
    "\n",
    "    def __next__(self):\n",
    "        if len(self.data) == 0:\n",
    "            raise StopIteration\n",
    "\n",
    "        index = random.randint(0, len(self.data)-1)\n",
    "        index = int(index)\n",
    "        return self.data.pop(index)\n",
    "\n",
    "number = [1, 2, 3, 4, 5, 6]\n",
    "number_random = RandomShuffle(number)\n",
    "\n",
    "print(*number)\n",
    "print(*number_random)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "843fc3cd-2917-4bc4-8f93-c97956c388b4",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "تابع randint(s,e) از کلاس random یک عدد تصادفی درون بازه [s,e] خروجی می‌دهد.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0573f2ef-2ed5-4790-8f58-a0e614c504f3",
   "metadata": {},
   "source": [
    "------------------------\n",
    "- __Underscore In Python__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5f62133e-baf7-4a20-9b6e-2f00bae192d0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test\n",
      "Test\n",
      "Test\n",
      "Test\n",
      "Test\n",
      "Test\n",
      "Test\n",
      "Test\n",
      "Test\n",
      "Test\n",
      "1 2\n"
     ]
    }
   ],
   "source": [
    "# Ignore a value of specific location/index\n",
    "for _ in range(10):\n",
    "    print (\"Test\")\n",
    "    pass\n",
    "\n",
    "# Ignore a value when unpacking\n",
    "a,b,_,_ = (1, 2, 3, 4)\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b7dec79-94a2-4213-a960-d7a85eeb7c56",
   "metadata": {},
   "source": [
    "- After a name"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4af7013-b1c9-45f3-b371-73dd21fc6e90",
   "metadata": {},
   "source": [
    "Python has their by default keywords which we can not use as the variable name. To avoid such conflict between python keyword and variable we use underscore after name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "98507e01-70cc-41e9-8e14-9119b6be5264",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "<class '__main__.MyClass'>\n"
     ]
    }
   ],
   "source": [
    "class MyClass():\n",
    "    def __init__(self):\n",
    "        print (\"OWK\")\n",
    "        pass\n",
    "    pass\n",
    "\n",
    "def my_defination(var1 = 1, class_ = MyClass):\n",
    "    print (var1)\n",
    "    print (class_)\n",
    "\n",
    "my_defination()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7aac5533-ef88-4cc0-a7f5-9a597fc27341",
   "metadata": {},
   "source": [
    "- Before a name"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "efd72d8c-8dbd-4d42-b1e4-190972b84459",
   "metadata": {},
   "source": [
    "Leading Underscore before variable/function/method name indicates to programmer that It is for internal use only.\n",
    "Here name prefix by underscore is treated as non-public. If specify from Import * all the name starts with _ will not import. Python does not specify truly private so this ones can be call directly from other modules if it is specified in __all__, We also call it weak Private"
   ]
  },
  {
   "cell_type": "raw",
   "id": "2407cf83-556d-4547-bb54-a92d30217810",
   "metadata": {},
   "source": [
    "# class_file.py file\n",
    "def public_api():\n",
    "    print (\"public api\")\n",
    "\n",
    "def _private_api():\n",
    "    print (\"private api\")\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "40ad316b-bc90-475e-ad76-af44ff832b19",
   "metadata": {},
   "source": [
    "# calling file from prompt\n",
    ">>> from class_file import *\n",
    ">>> public_api()\n",
    "public api\n",
    "  \n",
    ">>> _private_api()\n",
    "Traceback (most recent call last):\n",
    "File \"<stdin>\", line 1, in <module>\n",
    "NameError: name '_private_api' is not defined\n",
    "  \n",
    ">>> import class_file\n",
    ">>> class_file.public_api()\n",
    "public api\n",
    ">>> class_file._private_api()\n",
    "private api"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf84baf7-249c-4ed6-af71-b410ea3d3105",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "-----------------------------\n",
    "### 2.11. Module"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "730c2834-3597-4863-9f08-3ccd68754a31",
   "metadata": {},
   "source": [
    "#### 2.11.1. Module "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "247df35e-93df-4d12-bd2e-0df321b3ca06",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "ماژول‌ها به شما این امکان را می‌دهند که پروژه خود را راحت‌تر مدیریت کنید. به‌طور کلی ماژول‌ یک فایل پایتونی است که شامل مجموعه‌ای از ویژگی‌ها از قبیل کلاس‌ها، توابع، متغیرها و حتی کدهای قابل اجرا (runnable code) می‌باشد. فرض کنید دو فایل پایتونی به‌نام test.py و main.py دارید. حال اگر از ویژگی‌های test.py در main.py استفاده کنید، فایل test.pyبه عنوان یک ماژول در نظر گرفته شده است. اما برای این کار ابتدا باید test.py را به main.pyاضافه کنید.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad36a33c-6bd7-4f1f-a5fe-7f1e267d2722",
   "metadata": {},
   "source": [
    "- Standard module : means python itself supports it, and the module is with python from begining."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b12210a-17c0-40f4-ae65-a94ef3a8b178",
   "metadata": {},
   "source": [
    "#### 2.11.2. \"import\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b95e1392-504d-40fa-abb3-4a48d6aaf26c",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "این دستور تمام ویژگی‌هایی که در یک فایل پایتون مثل کلاس‌ها، توابع، متغیرها و ... قرار دارند را به برنامه ما اضافه می‌کند. برای استفاده از آنها کافی‌ست اول نام آن فایل یا ماژول و سپس نام ویژگی موردنظر را بنویسید. برای مثال بعد از اضافه‌ کردن کتابخانه ‍‍math به این شکل می‌توانستید به همه توابع و متغیرهای آن دسترسی داشته‌ باشید و یا حتی آن‌ها را تغییر دهید. البته توجه کنید که این تغییر دادن به صورت محلی است یعنی بار بعدی که کتابخانه را اضافه کنیم همان مقدار قبلی را دریافت خواهیم کرد.\n",
    "<br>\n",
    "برای فهمیدن بیشتر این موضوع فرض کنید پروژه‌ای داریم که ساختار آن به شکل زیر است :\n",
    "</div>"
   ]
  },
  {
   "cell_type": "raw",
   "id": "7d44108f-67f3-4295-a0f2-3d9485b207a6",
   "metadata": {},
   "source": [
    ".\n",
    "├── controller.py\n",
    "├── main\n",
    "│   ├── main.py\n",
    "│   └── test.py\n",
    "└── model.py"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a14ca9f0-1820-48a1-9d0e-c782c65824c8",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "و در فایل test.py کد زیر وجود دارد.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "raw",
   "id": "ffc266c6-c605-49b6-8e91-2cc9150b8a06",
   "metadata": {},
   "source": [
    "def print_test():\n",
    "    print(\"test file\")\n",
    "\n",
    "class Test:\n",
    "    def __init__(self, x):\n",
    "        self.x = x\n",
    "\n",
    "    def print(self):\n",
    "        print(self.x)\n",
    "\n",
    "a = 10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1f5f7f6-a66b-4ab6-bd5c-54ce9413c7b3",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "حالا فرض کنید می‌خواهیم در فایل main.py به این سه ویژگی که در فایل test.py قرار دارند دسترسی پیدا کنیم. برای این کار می‌توانیم با استفاده از دستور import test ویژگی‌های آن فایل را داشته باشیم. برای فهم بیشتر کد زیر را که در main.py نوشته شده را در نظر بگیرید.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "raw",
   "id": "926a97e8-0685-4911-9897-37c020bde68e",
   "metadata": {},
   "source": [
    "import test\n",
    "test.print_test()\n",
    "x = test.Test(4)\n",
    "x.print()\n",
    "print(test.a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66c39f5d-1b54-4efd-970f-4280b5ce5801",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "که با اجرا کردن آن خروجی زیر تولید می‌شود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "raw",
   "id": "dd8092f5-93eb-4799-9616-51d9caa772f3",
   "metadata": {},
   "source": [
    "test file\n",
    "4\n",
    "10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25dfabf1-5d80-4789-bbca-1c0b43049aae",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "همان‌طور که می‌بینید در خط بعد از import تابع test_print فایل test.py را صدا زده‌ایم و عبارت test file چاپ شده‌است. پس از آن یک شی از نوع ‍‍Test ساختیم و تابع print آن را صدا زده‌ایم و بعد از آن هم مقدار متغیر a را چاپ کرده‌ایم و همان خروجی که انتظار داشتیم چاپ شده است.\n",
    "<br>\n",
    "هم‌چنین می‌توانیم در خود مفسر هم عملیات import کردن را انجام دهیم، سپس به ویژگی‌ها دسترسی داشته باشیم. برای مثال مفسر زیر در همان‌جایی که فایل main.py قرار دارد اجرا شده‌است.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "raw",
   "id": "0c83bf11-ddf8-4c02-b30f-68a85e2dcc33",
   "metadata": {},
   "source": [
    ">>> import test\n",
    ">>> test.a\n",
    "10\n",
    ">>> test.print_test()\n",
    "test file\n",
    ">>> test.Test\n",
    "<class 'test.Test'>\n",
    ">>> type(test)\n",
    "<class 'module'>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dbe41743-f813-42d8-a3ce-59e2b44e73d1",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "همان‌طور که می‌بینید نوع خود test هم module است و می‌توان به چشم متغیر به آن نگاه کرد و مقدار آن را تغییر داد. برای فهم بیشتر مثال زیر را که ادامه مفسر قبلی است در نظر بگیرید.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "raw",
   "id": "d9fca704-6c4e-4577-a77c-eee29860e563",
   "metadata": {},
   "source": [
    ">>> test.a = 20\n",
    ">>> test.a\n",
    "20\n",
    ">>> test = 4\n",
    ">>> test.print_test()\n",
    "Traceback (most recent call last):\n",
    "  File \"<stdin>\", line 1, in <module>\n",
    "AttributeError: 'int' object has no attribute 'test_print'\n",
    ">>> import test\n",
    ">>> test.a\n",
    "20"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3aeb4ff-4cf1-4b4d-98cb-e6c0c6849497",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "همان‌طور که می‌بینید می‌توانیم مقدار یک ویژگی را تغییر دهیم و پس از این، این مقدار در فراخوانی‌های بعدی تغییر می‌کند. همچنین اگر مقدار خود test را تغییر دهیم، دیگر همان جنس قبلی را ندارد و مقدار آن به کلی تغییر می‌کند. اگر بخواهیم دوباره به مقدار قبلی دسترسی داشته‌باشیم، می‌توانیم دوباره آن را import کنیم. همان‌طور که می‌بینید متغیر a مقدار ۲۰ را دارد و یعنی تغییر قبلی روی آن اعمال شده است. اما اگر این مفسر را ببندید و مفسر دیگری را اجرا کنید با گرفتن مقدار a همان مقدار قبلی، یعنی ۱۰ چاپ می‌شود. یعنی تغییراتی که روی یک module اعمال می‌کنیم به صورت محلی (Local) در آن اعمال می‌شود و بار بعدی که به آن دسترسی پیدا می‌کنیم تغییرات تاثیری نخواهند داشت.\n",
    "<br>\n",
    "فرض کنید که فایل پایتونی که می‌خواهید از آن import کنید مستقیما در کنار جایی که از آن import می‌کنید وجود نداشته‌ باشد، در آن صورت می‌توانید آدرس نسبی فایلی که می‌خواهید از آن import شود را بنویسید و آن را به‌جای / با ‍‍. جدا کنید. برای مثال فرض‌ کنید که مفسر را در پوشه‌ای که controller.py در آن قرار دارد اجرا می‌کنیم. در آن صورت می‌توانیم برای دسترسی به test.py از ‍‍main.test استفاده کنید که همان آدرس نسبی test.py است و می‌توانید مثال آن را در زیر ببینید.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "raw",
   "id": "4d886f2d-2133-47f5-82f2-8935bce748bb",
   "metadata": {},
   "source": [
    ">>> import main.test\n",
    ">>> main.test.a\n",
    "10\n",
    ">>> main.test.print_test()\n",
    "test file\n",
    ">>> type(main.test)\n",
    "<class 'module'> "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9e4fb32-ae5a-48d5-9fde-6519315b8bf3",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "حال فرض کنید همان محتویات فایل test.py در controller.py هم وجود دارد و می‌خواهیم آن‌ها را از مفسری که در پوشه main قرار دارد، import کنیم. (یعنی در آدرس‌دهی به این نیاز داشته باشیم که به پوشه پدر اشاره کنیم.) در آن صورت می‌توانیم از .. استفاده‌کنیم.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85b73b1a-85ee-4809-9bda-b94c228c3ed6",
   "metadata": {},
   "source": [
    "#### 2.11.3. \"from\" keyword"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d59e8d6a-f774-48ea-ac8a-c0d08878d860",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "با استفاده از from‍می‌توان یک ویژگی را بدون این که کل module یا همان فایل را اضافه کنیم، import کنیم. در آن صورت برای دسترسی به آن ویژگی کافیست تا آن را به صورت مستقیم صدا کنیم و دیگر نیازی به نوشتن نام module نیست. نحوه استفاده از این دستور به این صورت است که بعد از from نام moduleای که می‌خواهیم از آن import شود را می‌نویسیم(همان آدرس فایل) و بعد از آن کلید واژه import و نام ویژگی‌هایی که می‌خواهیم اضافه شوند را می‌نویسیم. (در صورتی که بخواهیم چند ویژگی اضافه کنیم آن‌ها را با , از هم جدا می‌کنیم.)\n",
    "<br>\n",
    "برای مثال به مفسری که در پوشه main اجرا شده‌است توجه‌کنید.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "raw",
   "id": "6a2cc386-ae9f-4839-bffa-65a9a1a9adbc",
   "metadata": {},
   "source": [
    ">>> from test import a\n",
    ">>> a\n",
    "10\n",
    ">>> from test import print_test , Test\n",
    ">>> print_test()\n",
    "test file\n",
    ">>> type(Test)\n",
    "<class 'type'>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ff29d40-4276-4e22-986d-dd40bdcf2d77",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "همان طور که می‌بینید با استفاده از from توانسته‌ایم ویژگی ‌های test را به طور مستقیم اضافه کنیم. همچنین در صورتی که بخواهیم تمام ویژگی‌های یک module را به طور مستقیم اضافه کنیم می‌توانیم بعد از import کاراکتر * را بنویسیم که نشان می‌دهد می‌خواهیم تمام ویژگی‌ها را اضافه کنیم. برای مثال فرض کنید می‌خواهیم تمام ویژگی‌های کتابخانه math را به طور مستقیم اضافه کنیم، برای این کار می‌توانیم از کاری که در زیر انجام شده استفاده کنیم.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "raw",
   "id": "a9060d8d-804e-4a5b-a3ac-8e85234f38db",
   "metadata": {},
   "source": [
    ">>> from math import *\n",
    ">>> cos(pi)\n",
    "-1.0\n",
    ">>> sin(pi/2)\n",
    "1.0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db9de806-f08b-46d2-af3c-01799a610f6d",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "همان طور که می‌بینید می‌توانیم به همه ویژگی‌ها به صورت مستقیم دسترسی داشته باشیم و دیگر لازم نیست قبل از اسم هر تابع عبارت ‍‍math. را بنویسیم.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92a8a882-fcb4-496d-aa69-9115c9a7d209",
   "metadata": {},
   "source": [
    "#### 2.11.3. \"as\" keyword"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ba08b6d-8e57-4e3a-8397-e3b088fbfaf6",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "با استفاده از کلیدواژه ‍‍as می‌توان یک ویژگی را به صورت مستقیم اما با یک نام دیگر به برنامه اضافه کرد. شیوه استفاده از این کلیدواژه به این صورت است که بعد از این که به وسیله from آن ویژگی را مشخص کردیم، می‌توانیم از کلیدواژه as استفاده کنیم و بعد از آن نامی را که می‌خواهیم ویژگی داشته باشد می‌نویسیم.\n",
    "<br>\n",
    "برای درک بیشتر به مثال زیر توجه کنید.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "raw",
   "id": "eff36f4f-0394-4187-a43e-debdac16152e",
   "metadata": {},
   "source": [
    ">>> from math import sin as cos\n",
    ">>> from math import cos as sin\n",
    ">>> from math import pi as p\n",
    ">>> sin(p)\n",
    "-1.0\n",
    ">>> cos(p/2)\n",
    "1.0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d134713-dafe-4f4d-bc70-3da9ebe33034",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "همان‌طور که می‌بینید تابع‌های sin و cos را به شکل برعکس به برنامه اضافه کردیم و بعد از آن هم \\piπ را با نام p اضافه کردیم. می‌بینید که دو تابع sin و cos به جای یک‌دیگر کار می‌کنند.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4dbd4330-e238-459c-9e4a-4f27ae8d1952",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "---------------------------\n",
    "### 2.12. Debug "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93f85af7-1d95-4292-b710-9259dd2986eb",
   "metadata": {},
   "source": [
    "#### 2.12.1. Using \"print()\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24193913-580f-4187-ba73-6c924ed5885c",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "در خیلی از موارد امکان استفاده از assert به جای ‍print هم هست.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "52961763-56cd-4251-b89f-0500626b4086",
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "num must be a number",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_10880/3950812796.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      4\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[1;36m100\u001b[0m \u001b[1;33m/\u001b[0m \u001b[0mn\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 6\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdivide\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Yang'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_10880/3950812796.py\u001b[0m in \u001b[0;36mdivide\u001b[1;34m(num)\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mdivide\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnum\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m     \u001b[1;32massert\u001b[0m \u001b[0mtype\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnum\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m==\u001b[0m \u001b[0mint\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'num must be a number'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      3\u001b[0m     \u001b[0mn\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnum\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[1;36m100\u001b[0m \u001b[1;33m/\u001b[0m \u001b[0mn\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mAssertionError\u001b[0m: num must be a number"
     ]
    }
   ],
   "source": [
    "def divide(num):\n",
    "    assert type(num) == int, 'num must be a number'\n",
    "    n = int(num)\n",
    "    return 100 / n\n",
    "\n",
    "print(divide('Yang'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0e8ec9f5-c9ea-444a-bea8-0cc50a51825b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "print(divide(100))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "828a90c7-5b82-4168-8b72-532ad7457842",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "در خط اول از تابع divide بررسی می‌شود که آیا جنس آرگومان ورودی (num) برابر int است یا خیر. اگر از این جنس بود به ادامه‌ی برنامه پرداخته می‌شود ولی اگر از جنس دیگری (مانند str یا float یا ...) بود؛ استثنای AssertionError به همراه عبارتی که بعد از , نوشته شده است، پرتاب می‌شود.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e38f22ac-4234-44d1-9c6c-639bbd71b042",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "همانطور که در مثال نشان داده‌شده، متد ‍‍assert که از متدهای پیش‌فرض (built-in) پایتون است، درصورتی که نتیجه عبارت False باشد استثنای ‍AssertionError را پرتاب می‌کند.\n",
    "<br>\n",
    "همچنین پایتون به ما این امکان را می‌دهد زمانی که از assert استفاده می‌کنیم با استفاده از پارامتر ‍ -O هیچ‌کدام از assertها را در نظر نگیریم.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "raw",
   "id": "c6b2179e-923d-41a8-b552-d6e7e374221c",
   "metadata": {},
   "source": [
    "python O- assert.py\n",
    "# Traceback (most recent call last):\n",
    "#   ...\n",
    "# ValueError: invalid literal for int() with base 10: 'Yang'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "deaec3de-2aca-4987-81df-969cdc1f0c21",
   "metadata": {},
   "source": [
    "#### pdb"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad5acf0a-3fac-4b9c-a137-626c04b41e82",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "روش دیگر استفاده از python debugger، pdb است. pdb ابراز دیباگ built-in پایتون است. برای قابلیت های بیشتر بهتر است به سراغ IDE ها بروید، اما گاهی ممکن است ترجیح دهید از pdb یا موارد مشابه مانند: web-pdb ,‌ pudb و ... استفاده کنید\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "668d5d2c-cda8-4b07-a1fe-280cc6dd1cb3",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "<h5> یک مثال ساده </h5>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c11a6b3-81ee-4bb9-b599-8a497e9b8970",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "در مثال زیر از pdb برای اجرای گام به گام کد استفاده می‌کنیم.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "raw",
   "id": "1c36698f-5f08-40e4-b324-dd7329dcacc1",
   "metadata": {},
   "source": [
    "s = '0'\n",
    "n = int(s)\n",
    "print(1000 / n)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9982848-b0e2-445d-91de-000ecdc871f4",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "در ابتدا به روش زیر برنامه اجرا می‌کنیم.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "raw",
   "id": "a48e99fb-5621-4bf1-ba73-e467b1fffc5a",
   "metadata": {},
   "source": [
    "python -m pdb test.py"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91fbedd2-93e0-4227-b1ce-bcfced1b5ebc",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "حالا برنامه از خط اول، خط به خط اجرا می‌کند.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "raw",
   "id": "66973084-2356-4e6e-93a3-67a413933469",
   "metadata": {},
   "source": [
    "> /home/yang/test.py(1)<module>()\n",
    "-> s = '0'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4586fc5-4efe-434a-97d1-0bd0269d4765",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "با دستور l می‌توان تمام کد را مشاهده کرد.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "raw",
   "id": "b93f52ff-47b0-46f1-8bc4-da03f1bc4a5a",
   "metadata": {},
   "source": [
    "(Pdb) l\n",
    "  1  -> s = '0'\n",
    "  2     n = int(s)\n",
    "  3     print(1000 / n)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "789e5d0b-cdfa-4c1b-b49c-13f6c574092d",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "با دستور ‍n می‌توانید خط بعد را اجرا کنید.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "raw",
   "id": "3ccb74c5-bb01-4619-b762-be0326223ab6",
   "metadata": {},
   "source": [
    "(Pdb) n\n",
    "> /home/yang/test.py(2)<module>()\n",
    "-> n = int(s)\n",
    "(Pdb) n\n",
    "> /home/yang/test.py(3)<module>()\n",
    "-> print(1000 / n)\n",
    "(Pdb) n\n",
    "ZeroDivisionError: division by zero\n",
    "> /home/yang/test.py(3)<module>()\n",
    "-> print(1000 / n)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2456c968-38e7-485e-8539-fe12cc862004",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "در هر زمانی با دستور ‍p و نام متغیر می‌توان مقدار متغیر را بررسی کرد.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "raw",
   "id": "06e55c5c-8d33-4a0c-b705-61d0fd1cff08",
   "metadata": {},
   "source": [
    "(Pdb) p s\n",
    "'0'\n",
    "(Pdb) p n\n",
    "0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9369c0e2-823e-4354-ab03-3a5e82307ebc",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "اگر تعداد خطوط برنامه زیاد باشد ممکن است شروع از خط اول زمان‌گیر باشد. در چنین حالتی می‌توان از تابع ()pdb.set_trace برای قرار دادن breakpoint در کد استفاده کرد.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "raw",
   "id": "a5f9e64b-6c80-41ac-ae0d-aa6e65ea9c70",
   "metadata": {},
   "source": [
    "import pdb\n",
    "\n",
    "s = '0'\n",
    "n = int(s)\n",
    "pdb.set_trace() \n",
    "# The program will be paused and start pdb debugger\n",
    "print(1000 / n)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f8da032-6919-4ed9-9ebf-8aad2d1954f4",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "اگر برنامه بالا را اجرا کنیم نتیجه‌ای مانند زیر دریافت می‌کنیم:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "raw",
   "id": "fc8ddf94-e1ef-486e-a2b8-aa6820823f5a",
   "metadata": {},
   "source": [
    "> /home/yang/test.py(7)<module>()\n",
    "-> print(1000 / n)\n",
    "(Pdb)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0378549-3085-4cfd-95d6-e2a1ca7aa133",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "و می‌توانیم از خط print(1000/n) اجرا را ادامه دهیم.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7e6d218-a89f-4737-b5a3-f77ab480f8f0",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "    <li>برای موارد بیشتر از این <a href=\"https://jonskeet.uk/csharp/debugging.html\" target=\"_blank\">لینک</a> استفاده کنید.</li>.\n",
    "    <li>برای آشنایی کامل‌تر با <em>pdb</em> این <a href=\"https://realpython.com/python-debugging-pdb/\" target=\"_blank\">مقاله</a> را مطالعه بفرمایید.</li>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6819e105-a6d7-4d61-bf9b-a1a09c654c06",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "-------------------------------\n",
    "## 3. Pakage Managment"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98786817-0f9d-49d6-83b7-2854f060c688",
   "metadata": {},
   "source": [
    "\n",
    "- __Python: Module vs Package vs Library vs Framework__"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dae80ace-92b4-4bf9-92d0-8f6c1ac185ff",
   "metadata": {},
   "source": [
    "<div>\n",
    "Module is a file which contains various Python functions and global variables. It is simply just .py extension file which has python executable code.\n",
    "<br>\n",
    "Package is a collection of modules. It must contains an __init__.py file as a flag so that the python interpreter processes it as such. The __init__.py could be an empty file without causing issues.\n",
    "<br>\n",
    "    It’s important to keep in mind that all packages are modules, but not all modules are packages. Or put another way, packages are just a special kind of module. Specifically, any module that contains a __path__ attribute is considered a package.\n",
    "    <br>\n",
    "Library is a collection of packages.\n",
    "<br>\n",
    "Framework is a collection of libraries. This is the architecture of the program.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77d393e5-4013-40b3-95d0-52ae93c5887e",
   "metadata": {},
   "source": [
    "<div>\n",
    "Package is a collection of modules. It must contains an __init__.py file as a flag so that the python interpreter processes it as such. The __init__.py could be an empty file without causing issues.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "raw",
   "id": "2641f13c-b2e1-4bcb-82d8-62dc74b93253",
   "metadata": {},
   "source": [
    "sound/                          Top-level package\n",
    "      __init__.py               Initialize the sound package\n",
    "      formats/                  Subpackage for file format conversions\n",
    "              __init__.py\n",
    "              wavread.py\n",
    "              wavwrite.py\n",
    "              aiffread.py\n",
    "              aiffwrite.py\n",
    "              auread.py\n",
    "              auwrite.py\n",
    "              ...\n",
    "      effects/                  Subpackage for sound effects\n",
    "              __init__.py\n",
    "              echo.py\n",
    "              surround.py\n",
    "              reverse.py\n",
    "              ...\n",
    "      filters/                  Subpackage for filters\n",
    "              __init__.py\n",
    "              equalizer.py\n",
    "              vocoder.py\n",
    "              karaoke.py\n",
    "              ..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf311509-2d60-4152-ae9d-7aaca65ab969",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "در بخش‌های قبل با کتابخانه‌های استاندارد پایتون مانند math آشنا شدید. این کتابخانه‌ها به صورت پیشفرض در کنار پایتون قرار دارند. برخی از کتابخانه‌های مفید (که به طور پیشفرض همراه پایتون نیستند) را باید به سیستم اضافه‌کنیم. مدیریت‌کردن این کتابخانه‌های افزوده معمولا دشوار است.\n",
    "<br>\n",
    "می‌توانیم از pip جهت مدیریت این بسته‌‌‌ها استفاده‌کنیم. برای اطلاع از نحوه نصب pip به این‌جا مراجعه‌کنید.\n",
    "<br>\n",
    "حال با استفاده از دستور زیر می‌توانید یک کتابخانه را به سیستم اضافه‌کنید. (این دستور را باید در cmd و یا terminal اجرا کنید.)\n",
    "</div>"
   ]
  },
  {
   "cell_type": "raw",
   "id": "c629e669-4ad7-4ed0-8d1a-3fc66f675336",
   "metadata": {},
   "source": [
    "> py -m pip install package-name"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "694a31a8-42ca-4c9f-80a5-3d3410c7e2df",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "برای مثال می‌توانید کتابخانه pygame را با استفاده از همین دستور نصب کنید. (توجه‌کنید که چون از پایتون۳ استفاده می‌کنیم باید در ترمینال هم از pip3 استفاده‌کنیم.)\n",
    "<br>\n",
    "همچنین با استفاده از دستور زیر می‌توانید همه کتابخانه‌هایی که در سیستم موجود است را به همراه نسخه‌ای که دارند مشاهده‌کنید.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "raw",
   "id": "d866e302-a947-49cc-964a-052e7f4cefb9",
   "metadata": {},
   "source": [
    "> py -m pip list\n",
    "pycairo (1.16.2)\n",
    "pycrypto (2.6.1)\n",
    "pycups (1.9.73)\n",
    "pygame (1.9.6)\n",
    "pyglet (1.3.2)\n",
    "Pygments (2.3.1)\n",
    "pygobject (3.26.1)\n",
    "pymacaroons (0.13.0)\n",
    "PyNaCl (1.1.2)\n",
    "pyRFC3339 (1.0)\n",
    "python-apt (1.6.3+ubuntu1)\n",
    "python-dateutil (2.7.5)\n",
    "python-debian (0.1.32)\n",
    "pytz (2018.3)\n",
    "pyxdg (0.25)\n",
    "PyYAML (3.12)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5211abe5-2a73-4575-8ef6-6a2f23e51b7a",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "در لیست بالا می‌توانید برخی از کتابخانه‌هایی که خروجی داده‌شدند را مشاهده کنید. مقدار درون پرانتز نسخه آن کتابخانه را نشان می‌دهد.\n",
    "<br>\n",
    "همچنین با استفاده از دستور uninstall می‌توانید یک package نصب‌شده را از سیستم حذف کنید.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "raw",
   "id": "7865b780-5681-424f-b900-d7b8ddf85303",
   "metadata": {},
   "source": [
    "> py -m pip uninstall pygame"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5026c62-3021-4dea-8ea1-4e50649295c5",
   "metadata": {},
   "source": [
    "<div style = \"direction:rtl\">\n",
    "برای مثال در نمونه‌ی بالا کتابخانه pygame را که نصب کردیم حذف می‌کنیم.\n",
    "<br>\n",
    "برای اطلاع از قابلیت‌های بیشتر pip می‌‌توانید با نوشتن دستور زیر در ترمینال، در خروجی اطلاعت مفیدی در این مورد دریافت کنید.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "raw",
   "id": "76fa22ef-f05f-4a7b-a117-8c0e3a18d6b9",
   "metadata": {},
   "source": [
    "> py -m pip --help"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9e74bb8-4335-49a6-bfce-979d03131eea",
   "metadata": {
    "tags": []
   },
   "source": [
    "---------------------------\n",
    "### 2.13. Virtual Environment"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "872e6801-b12f-4d52-9c3d-c950c26a7764",
   "metadata": {},
   "source": [
    "https://quera.ir/college/3078/chapter/9151/lesson/31129/?comments_page=1&comments_filter=ALL"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b09a848d-fc5c-4588-8826-e66b212549e4",
   "metadata": {},
   "source": [
    "---------------------------------------"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.12 ('.venv0')",
   "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.12.1"
  },
  "vscode": {
   "interpreter": {
    "hash": "cd22b8de970031b64b95571ae0647d884aa7eb2467981ae7c9db628297672c8f"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}