01-Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"direction:rtl;line-height:300%;\"><font face=\"XB Zar\" size=5>\n",
    "<div style=\"direction:rtl;line-height:300%;\"><font face=\"XB Zar\" size=5>\n",
    "<div align=center>\n",
    "<font face=\"IranNastaliq\" size=30>\n",
    "<p></p>\n",
    "به نام خدا\n",
    "</font>\n",
    "<br>\n",
    "<font color=#FF7500>\n",
    "دانشگاه صنعتی شریف - دانشکده مدیریت و اقتصاد شریف\n",
    "</font>\n",
    "<br>\n",
    "<font color=blue>\n",
    "اقتصاد سنجی ۱\n",
    "</font>\n",
    "<br>\n",
    "ترم پاییز سال تحصیلی ۱۴۰۳-۱۴۰۲\n",
    "<br>\n",
    "دکتر کوثر یوسفی\n",
    "    </div>\n",
    "<hr/>\n",
    "<font color=red size=6>\n",
    "<p></p>\n",
    "\n",
    "<div align=center>بخش اول: آموزش پایتون</div>\n",
    "</font>\n",
    "<div align=center>\n",
    "نگین جعفری، محمدمهدی جراحی</div>\n",
    "<hr>\n",
    "</font></div>\n",
    "\n",
    "\n",
    "<style type=\"text/css\" scoped>\n",
    "p{\n",
    "border: 1px solid #a2a9b1;background-color: #f8f9fa;display: inline-block;\n",
    "};\n",
    "</style>\n",
    "\n",
    "<div>\n",
    "<h3> فهرست محتویات</h3>\n",
    "<ul style=\"margin-right: 0;\">\n",
    "    <li><a href=\"#section0\">مقدمه: معرفی پایتون</a></li>\n",
    "    <li><a href=\"#section1\">متغییرها</a></li>\n",
    "    <li><a href=\"#section2\">انواع داده پایه‌ای</a></li>\n",
    "    <li><a href=\"#section3\">شرط‌ها: if</a></li>\n",
    "    <li><a href=\"#section4\">‌Blockها</a></li>\n",
    "    <li><a href=\"#section5\">لیست‌ها</a></li>\n",
    "    <li><a href=\"#section6\">mutable / immutable</a></li>\n",
    "    <li><a href=\"#section7\">زوج‌های مرتب</a></li>\n",
    "    <li><a href=\"#section8\">مجموعه‌ها</a></li>\n",
    "    <li><a href=\"#section9\">دیکشنری‌ها</a></li>\n",
    "    <li><a href=\"#section10\">حلقه‌ها</a></li>\n",
    "    <li><a href=\"#section11\">import</a></li>\n",
    "    <li><a href=\"#section12\">توابع</a></li>\n",
    "</ul>\n",
    "<div align=right>\n",
    "منبع: درس ساختمان داده‌ها دکتر علی شریفی زارچی</div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false
   },
   "source": [
    "<div style=\"direction:rtl;line-height:300%;\"><font face=\"XB Zar\" size=5>\n",
    "<div class=\"persian\" id=\"section0\">\n",
    "<h3>معرفی Python</h3>\n",
    "\n",
    "پایتون یک زبان برنامه نویسی متن بازِ تفسیریِ سطح بالا که سال ۱۹۹۱ توسط خَودو فان روسوم ساخته شده. طراحی پایتون بر خوانایی کد، و تعداد خطوط کمتر برای بیان مفاهیم و در نتیجه زمان کمتر برای پیاده‌سازی تاکید دارد. \n",
    "\n",
    "</div>\n",
    "</font></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world!\n"
     ]
    }
   ],
   "source": [
    "print(\"hello world!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Zen of Python, by Tim Peters\n",
      "\n",
      "Beautiful is better than ugly.\n",
      "Explicit is better than implicit.\n",
      "Simple is better than complex.\n",
      "Complex is better than complicated.\n",
      "Flat is better than nested.\n",
      "Sparse is better than dense.\n",
      "Readability counts.\n",
      "Special cases aren't special enough to break the rules.\n",
      "Although practicality beats purity.\n",
      "Errors should never pass silently.\n",
      "Unless explicitly silenced.\n",
      "In the face of ambiguity, refuse the temptation to guess.\n",
      "There should be one-- and preferably only one --obvious way to do it.\n",
      "Although that way may not be obvious at first unless you're Dutch.\n",
      "Now is better than never.\n",
      "Although never is often better than *right* now.\n",
      "If the implementation is hard to explain, it's a bad idea.\n",
      "If the implementation is easy to explain, it may be a good idea.\n",
      "Namespaces are one honking great idea -- let's do more of those!\n"
     ]
    }
   ],
   "source": [
    "# PEP0020, Zen of Python!\n",
    "import this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"direction:rtl;line-height:300%;\" id=\"section1\"><font face=\"XB Zar\" size=5>\n",
    "<h3>متغیر‌ها</h3>\n",
    "پایتون یک زبان نوع-پویا\n",
    "(dynamically typed) است.\n",
    "یعنی اشیا (objects) در پایتون نوع دارند اما متغیر‌ها نوع ندارند.\n",
    "</font></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "True\n",
      "<class 'str'>\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "var = 10\n",
    "print(type(var))\n",
    "print(isinstance(var, int))\n",
    "\n",
    "var = 'salam'\n",
    "print(type(var))\n",
    "print(isinstance(var, int))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"direction:rtl;line-height:300%;\" id=\"section2\"><font face=\"XB Zar\" size=5>\n",
    "<h3>انواع داده‌ای پایه:</h3>\n",
    "<ul>\n",
    "    <li>Boolean یا همان: True و False (به بزرگ و کوچک بودن حروف دقت کنید)</li>\n",
    "    <li>اعداد: int, long, float, complex</li>\n",
    "    <li>رشته‌ها</li>\n",
    "    <li>None: معادل NULL در C++</li>\n",
    "</ul>\n",
    "</font></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9.5\n",
      "0.6\n",
      "1.7142857142857142\n",
      "(3+3j)\n",
      "5j\n",
      "312791953184952432773037647427847997734252247042927663351793818343238523007334595314754865270114370908249\n",
      "9.0\n",
      "9.856\n"
     ]
    }
   ],
   "source": [
    "a = 6         # int\n",
    "b = 10        # long, well longer!\n",
    "d = 3.5       # float (there is no double)\n",
    "c1 = 1+2j     # complex\n",
    "c2 = 2+1j\n",
    "big_int = 123 ** 50\n",
    "print(a + d) \n",
    "print(a / b)   # int division\n",
    "print(a / d)\n",
    "print(c1 + c2) # complex addition\n",
    "print(c1 * c2) # complex multiplication\n",
    "print(big_int) # python has big-integers\n",
    "\n",
    "a1 = 12.5\n",
    "a2 = 123.2\n",
    "print(a2 // a1)\n",
    "print(a2 / a1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s1: hello guys, i'm a string!\n",
      "s2: hi, i'm a string \n",
      " \ttoo!\n",
      "s3: i'm \n",
      "a multiline\n",
      "string!\n",
      "s4: i'm another string\n",
      "haha haha haha \n",
      "number 2\n"
     ]
    }
   ],
   "source": [
    "s1 = 'hello guys, i\\'m a string!'\n",
    "s2 = \"hi, i'm a string \\n \\ttoo!\"\n",
    "s3 = \"\"\"i'm \n",
    "a multiline\n",
    "string!\"\"\"\n",
    "s4 = \"i'm another st\\\n",
    "ring\"\n",
    "\n",
    "print('s1: ' + s1)\n",
    "print('s2: ' + s2)\n",
    "print('s3: ' + s3)\n",
    "print('s4: ' + s4)\n",
    "print\n",
    "print('haha ' * 3)  # no comment\n",
    "# print('number ' + 2)-> TypeError:\n",
    "#  --> cannot concatenate 'str' and 'int' objects\n",
    "print('number ' + str(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\\users\\documents\\..\n",
      "C:\\users\\documents\\..\n",
      "max: u\n",
      "min: .\n",
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "path = 'C:\\\\users\\\\documents\\\\..'\n",
    "raw_string = r'C:\\users\\documents\\..' #skip the skip character !\n",
    "\n",
    "print(path + '\\n' + raw_string)\n",
    "\n",
    "print('max: ' + max(path))\n",
    "print('min: ' + min(path))\n",
    "print('users' in path)\n",
    "print('Users' in path)\n",
    "\n",
    "str2 = 'python workshop'\n",
    "print('py' in str2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello user, welcome! 12312\n",
      "hello user, welcome! 12312\n",
      "hello user, welcome!\n",
      "hello user, welcome!\n"
     ]
    }
   ],
   "source": [
    "user = 'user'\n",
    "password = 12312\n",
    "print('hello %s, welcome! %d' % (user, password))\n",
    "print(f'hello {user}, welcome! {password}')\n",
    "print('hello {}, welcome!'.format(user))\n",
    "print('hello {user}, {greeting}!'.format(user=user, greeting='welcome'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "سلام\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'سلام'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fa = u'سلام'\n",
    "print(fa)\n",
    "fa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "a\n",
      "a wonderful life!\n",
      "a wonder\n",
      "a wonder\n",
      "it's a wonder\n",
      "it's a wonder\n"
     ]
    }
   ],
   "source": [
    "#substrings\n",
    "\n",
    "s = \"it's a wonderful life!\"\n",
    "print(s[5])\n",
    "print(s[-17])\n",
    "\n",
    "print(s[5:])\n",
    "print(s[5: 13])\n",
    "print(s[5: -9])\n",
    "print(s[: 13])\n",
    "print(s[: -9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " hello\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "# simple input reading\n",
    "a = input()\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"direction:rtl;line-height:300%;\" id=\"section3\"><font face=\"XB Zar\" size=5>\n",
    "<h3>If</h3>\n",
    "if\n",
    "درست همانطوری که فکر می‌کنید کار می‌کند، فقط با این تفاوت که نیازی نیست دور گزاره‌ی شرطی آن پرانتز بگذارید (گذاشتن آن هم مانعی ندارد). فقط یادتان نرود که در پایان این دستور باید یک کاراکتر دونقطه (:) نوشته شده و در خط بعدی آن یک بلاک جدید شروع شود.\n",
    "<br/>\n",
    "همچنین در پایتون\n",
    "else if\n",
    "نداریم و به جای آن باید از کلمه‌ی کلیدی \n",
    "<span class=\"codeM\">elif</span>\n",
    "استفاده کنید.\n",
    "<br/>\n",
    "همچنین همانند بقیه‌ی زبان‌ها گزاره‌های and و or به صورت\n",
    "اتصال‌کوتاه (short-circuit)\n",
    "اجرا می‌شوند.\n",
    "</font></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is greater than or equal to 5 and less than 10\n",
      "no error was thrown\n"
     ]
    }
   ],
   "source": [
    "a = 8\n",
    "if a < 5:\n",
    "    print('a is less than 5')\n",
    "elif (a < 10):  # this is okay too, but why bother?\n",
    "    print('a is greater than or equal to 5 and less than 10')\n",
    "else:\n",
    "    print('a is greater than or equal to 10')\n",
    "\n",
    "print  # just a newline\n",
    "\n",
    "if a < 10 or (2/0):\n",
    "    # the second one must throw a division by zero exception\n",
    "    print('no error was thrown')\n",
    "    # obviously or (also and) is short-circuited"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"direction:rtl;line-height:300%;\" id=\"section4\"><font face=\"XB Zar\" size=5>\n",
    "<h3>Block‌ها</h3>\n",
    "نحوه‌ی indent کردن کد (تورفتگی کد) \n",
    "در پایتون بلاک‌ها را از یکدیگر جدا می‌کند.\n",
    "\n",
    "یعنی پایتون شما را مجبور می‌کند که \n",
    "نحوه‌ی خاصی از تورفتگی‌های کد را استفاده کنید و همانند زبان‌های دیگر این مسئله در دست برنامه‌نویس نیست.\n",
    "<br/>\n",
    "هر tab یا تعدادی space می‌تواند یک مرحله تورفتگی را نشان بدهد.\n",
    "پس شما می‌توانید به انتخاب خودتان از space یا tab برای جدا کردن بلاک‌ها از یکدیگر استفاده کنید (در واقع در پایتون۲ هر ۴ space برابر یک tab است)\n",
    "اما بهتر است که این دو روش را با هم استفاده نکنید. به این دلیل که هم خوانایی کد را به شدت پایین می‌آورد و هم ترکیب کردن دو کد مختلف که یکی از tab و دیگری از space استفاده می‌کند بسیار می‌تواند سخت باشد. همچنین توصیه می‌شود فقط از space برای این کار استفاده کنید.\n",
    "<br/>\n",
    " با اضافه‌کردن یک مرحله تورفتگی، یک بلاک درونی جدید شروع می‌شود و با حذف کردن این تورفتگی بلاک قبلی تمام می‌شود.\n",
    " همیشه وقتی باید یک بلاک جدید شروع شود، یک کاراکتر دونقطه (:) حتما در انتهای خط قبلی آن وجود دارد.\n",
    " <br/>\n",
    " دستوراتی که بعدشان باید یک بلاک جدید شروع شود:\n",
    "<span class=\"codeM\">if و else و for و while و تعریف تابع (def) و ...</span>\n",
    "<br/>\n",
    "دقت کنید که یک بلاک نمی‌تواند هرگز خالی باشد. پس اگر به هر دلیلی بلاک خالی شد، می‌توانید از کلمه‌ی کلیدی\n",
    "<span class=\"codeM\">pass</span>\n",
    "برای خالی نماندن بلاک استفاده کنید.\n",
    "</font></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "block 1\n",
      "\tblock 1.1\n",
      "\t\tblock 1.1.1\n",
      "\tblock 1.2\n"
     ]
    }
   ],
   "source": [
    "if True:\n",
    "    print('block 1')\n",
    "    if True:\n",
    "        print('\\tblock 1.1')\n",
    "        if True:\n",
    "            print('\\t\\tblock 1.1.1')\n",
    "    if True:\n",
    "        print('\\tblock 1.2')\n",
    "    else:\n",
    "        # block 1.3, blocks can't be empty!\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"direction:rtl;line-height:300%;\" id=\"section5\"><font face=\"XB Zar\" size=5>\n",
    "<h3>لیست‌ها</h3>\n",
    "لیست‌های پایتون درست مثل vector (آرایه‌های با طول متغیر) در C++ یا Java اند.\n",
    "<br/>\n",
    "slicing یکی از قابلیت‌های بسیار مفید در پایتون است.\n",
    "</font></div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "length of lis: 5\n",
      "6\n",
      "5\n",
      "[2, 10]\n",
      "[2, 10, 3]\n",
      "[6, 2, 10]\n",
      "[3, 5]\n",
      "[6, 2, 10, 3, 5]\n",
      "['salam', 12, 5.23]\n"
     ]
    }
   ],
   "source": [
    "l = [6,\n",
    "     2,\n",
    "     10,\n",
    "     3,\n",
    "     5,]\n",
    "#  you can break the lines that are constrined by [] or () or {}\n",
    "# it can be a very good tool for increasing readability\n",
    "     \n",
    "#  also you can leave the last colon (,) be, it doesn't do any harm\n",
    "# it's not necessary either\n",
    "\n",
    "print('length of lis: ' + str(len(l)))\n",
    "\n",
    "print(l[0])     # the first item\n",
    "print(l[-1])    # the last item\n",
    "print(l[1:3])   # only the second and third item\n",
    "print(l[1:-1])  # everything but the first and the last item\n",
    "print(l[:3])    # the first 3 items\n",
    "print(l[-2:])   # the last 2 items\n",
    "print(l[0:100]) # no error! the whole list is returned\n",
    "\n",
    "# lists can contain different object types!\n",
    "l = ['salam', 12, 5.23]\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 3, 10, 2, 6]\n",
      "[2, 3, 5, 6, 10]\n",
      "[10, 6, 5, 3, 2]\n"
     ]
    }
   ],
   "source": [
    "l = [6,\n",
    "     2,\n",
    "     10,\n",
    "     3,\n",
    "     5,]\n",
    "l.reverse()\n",
    "print(l)        # list is reversed\n",
    "l.sort()\n",
    "print(l)        # list is sorted\n",
    "l.sort(reverse=True)\n",
    "print(l)        # list is sorted in reverse order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "welcome to HELL!\n"
     ]
    }
   ],
   "source": [
    "s = 'hello, welcome to python programming!'\n",
    "# string also have slicing!\n",
    "print(s[s.find('w'):s.find('w')+7] + ' to ' + s[:4].upper()+ '!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "range(0, 7)\n",
      "-- check existence:\n",
      "True\n",
      "False\n",
      "-- add:\n",
      "[0, 1, 2, 3, 4, 5, 6, 10, 7, 10]\n",
      "-- count:\n",
      "2\n",
      "-- remove:\n",
      "[0, 1, 2, 3, 4, 5, 6, 7, 10]\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "r = range(7)  # range makes lists\n",
    "#  there's also xrange which doesn't actually make the list\n",
    "# but we'll get to that later\n",
    "print(r)\n",
    "\n",
    "print('-- check existence:')\n",
    "print(3 in r)\n",
    "print(11 in r)\n",
    "\n",
    "print('-- add:')\n",
    "r=list(r)\n",
    "r.append(10)\n",
    "r.append(7)\n",
    "r.append(10)\n",
    "print(r)\n",
    "\n",
    "print('-- count:')\n",
    "print(r.count(10))\n",
    "\n",
    "print('-- remove:')\n",
    "r.remove(10)\n",
    "print(r)\n",
    "print(len(r))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n",
      "[0, 0, 11, 0, 11, 0, 0, 0, 0, 0]\n"
     ]
    }
   ],
   "source": [
    "arr = [0] * 10\n",
    "print(arr)\n",
    "\n",
    "arr[4] = arr[2] = 11\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]]\n",
      "[[13, 2, 3], [13, 2, 3], [13, 2, 3], [13, 2, 3]]\n",
      "[[13, 2, 3], [1, 2, 3], [1, 2, 3]]\n"
     ]
    }
   ],
   "source": [
    "# beware when using multiplication with lists and other objects\n",
    "arr = [[1,2,3]] * 4  # for example don't do this!\n",
    "print(arr)\n",
    "arr[0][0] = 13\n",
    "print(arr)\n",
    "\n",
    "# instead you can do this (we'll cover what this means later):\n",
    "arr = [[1,2,3] for _ in range(3)]\n",
    "arr[0][0] = 13\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"direction:rtl;line-height:300%;\" id=\"section6\"><font face=\"XB Zar\" size=5>\n",
    "<h3>mutable / immutable</h3>\n",
    "انواع داده‌ای در پایتون می‌توانند mutable (تغییرپذیر) یا immutable (تغییر ناپذیر) باشند. به عنوان مثال int, float, str تغییر ناپذیرند و list تغییرپذیر. \n",
    "در واقع در انواع داده‌ای تغییر ناپذیر اصالت با مقدار است و در تغییرپذیرها اصالت با آدرس اشیاء،\n",
    "به این معنی که ممکن است همه‌ی متغیرهای از یک نوع داده‌ای تغییرناپذیر با مقدار یکسان، آدرس و id\n",
    "یکسان نیز داشته‌باشند.\n",
    "<br> \n",
    "دقت نکردن به این موضوع می‌تواند اشکالات عجیبی به وجود بیاورد.\n",
    "</font></div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "id() of immutables\n",
      "4520722632 4520722632\n",
      "4520722664 4520722632\n",
      "4566079680\n",
      "4566079680\n",
      "[1, 1, 1] [1, 1, 1]\n",
      "[1, 3, 1] [1, 3, 1]\n",
      "[1, 1, 1] [1, 1, 1]\n",
      "[1, 1, 1] [1, 3, 1]\n",
      "Salam\n"
     ]
    }
   ],
   "source": [
    "# id() reperesent unique id for an object\n",
    "# when integer value changes, we have new object!\n",
    "print('id() of immutables')\n",
    "a = 12\n",
    "b = 12\n",
    "print(id(a), id(b))\n",
    "a = 13\n",
    "print(id(a), id(b))\n",
    "# beaware it's not always like this!\n",
    "\n",
    "# values in list change, but object id doesn't. \n",
    "a = [1, 1, 1]\n",
    "print(id(a))\n",
    "a[0] = 2\n",
    "print(id(a))\n",
    "\n",
    "a = [1, 1, 1]\n",
    "b = a\n",
    "print(a, b)\n",
    "b[1] = 3\n",
    "print(a, b) # it mean's a, b reference to same object\n",
    "\n",
    "a = [1, 1, 1]\n",
    "b = list(a) # allocation, new object\n",
    "print(a, b)\n",
    "b[1] = 3\n",
    "print(a, b)\n",
    "\n",
    "\n",
    "a = 'salam'\n",
    "# a[0] = 'S'\n",
    "# ---> TypeError: 'str' object does not support item assignment\n",
    "a = 'S' + a[1:]\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"direction:rtl;line-height:300%;\" id=\"section7\"><font face=\"XB Zar\" size=5>\n",
    "<h3>زوج (چند‌تایی)های مرتب</h3>\n",
    "زوج‌های مرتب درست همانند لیست‌های غیرقابل تغییرند.\n",
    "یکی از برتری‌های آن نسبت به لیست این است که زوج‌های مرتب Hashable اند. پس مثلا می‌توان آن‌ها را به عنوان کلید در یک Dictionary (که بعدا می‌بینیم) نگه‌داشت.\n",
    "<br/>\n",
    "مقداردهی زوج‌مرتبی نیز قابلیت بامزه‌ای است که در بعضی موارد می‌تواند تعداد خطوط لازم را تا حد خوبی کاهش دهد.\n",
    "</font></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "(10, 6)\n",
      "(10, 6, 19, 10, 6, 19)\n"
     ]
    }
   ],
   "source": [
    "t = (10,6,19)\n",
    "print(t[0])\n",
    "print(t[0:-1])\n",
    "print(t*2)\n",
    "\n",
    "# t[1] = 4 -> TypeError\n",
    "# t.append -> not supported"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "---\n",
      "3\n",
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "a, b, c = [1, 2, 3]\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)\n",
    "\n",
    "print('---')\n",
    "a, b, c = c, b, a  # 3-way swap in one statement!\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"direction:rtl;line-height:300%;\" id=\"section8\"><font face=\"XB Zar\" size=5>\n",
    "<h3>مجموعه‌ها</h3>\n",
    "مجموعه‌ها در پایتون همانند HashSet در Java یا set در C++ اند.\n",
    "<br/>\n",
    "مجموعه‌ها می‌توانند حداکثر یکی از هر چیز را نگه‌داری کنند (البته هر چیزی که در آن ذخیره می‌شود باید Hashable باشد.\n",
    "پس لیست‌ها و مجموعه‌های دیگر و Dictionary‌ها را نمی‌توان در یک مجموعه نگه‌داشت)\n",
    "</font></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, (1, 2), 'hasan'}\n",
      "5\n",
      "True\n",
      "False\n",
      "-- add:\n",
      "{1, 2, 3, (1, 2), 'hasan', 4}\n",
      "True\n",
      "-- remove:\n",
      "{1, 2, (1, 2), 'hasan', 4}\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "s = {1,2,3,3, (1,2), 'hasan'}\n",
    "print(s)\n",
    "print(len(s))\n",
    "print(1 in s)\n",
    "print(4 in s)\n",
    "\n",
    "print('-- add:')\n",
    "s.add(4)\n",
    "print(s)\n",
    "print(4 in s)\n",
    "\n",
    "print('-- remove:')\n",
    "s.remove(3)\n",
    "print(s)\n",
    "print(3 in s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"direction:rtl;line-height:300%;\" id=\"section9\"><font face=\"XB Zar\" size=5>\n",
    "<h3>Dictionary</h3>\n",
    "Dictionary‌ها\n",
    "(یا به اختصار dict)\n",
    "در پایتون بسیار مفیداند و همانند HashMap در Java و map در C++ عمل می‌کنند.\n",
    "<br/>\n",
    "در یک dict شما می‌توانید زوج‌های مرتب کلید و مقدار را ذخیره کرده و بعدا بر اساس کلید، مقدار‌ها را پیدا کنید.\n",
    "فقط دقت کنید که کلید باید Hashable باشد.\n",
    "</font></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "{'ali': 1, 'mamad': 2, 1: 3, (1, 2): 4}\n",
      "3\n",
      "True\n",
      "2\n",
      "4\n",
      "-- delete:\n",
      "False\n",
      "{'ali': 1, 'mamad': 2, (1, 2): 4}\n",
      "-- add:\n",
      "{'ali': 1, 'mamad': 2, (1, 2): 4, 'new': 123}\n"
     ]
    }
   ],
   "source": [
    "d = {'ali': 1,\n",
    "     'mamad': 2,\n",
    "     1: 3,\n",
    "     (1,2): 4,\n",
    "    }\n",
    "print(len(d))\n",
    "print(d)\n",
    "print(d[1])\n",
    "print(1 in d)\n",
    "print(d['mamad'])\n",
    "print(d[1,2])\n",
    "# when there's no ambiguity, the parantheses around tuples are not needed\n",
    "\n",
    "print('-- delete:')\n",
    "del d[1]\n",
    "# print d[1] -> KeyError\n",
    "print(1 in d)\n",
    "print(d)\n",
    "\n",
    "print('-- add:')\n",
    "d['new'] = 123\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"direction:rtl;line-height:300%;\"><font face=\"XB Zar\" size=5>\n",
    "<h3>مقدار True و False انواع پایه در گزاره‌های شرطی</h3>\n",
    "    مقادیر زیر در پایتون در یک گزاره‌ی شرطی مقدار False دارند:\n",
    "    <ul>\n",
    "        <li>False</li>\n",
    "        <li>None</li>\n",
    "        <li>صفر عددی: 0، 0.0، 0j</li>\n",
    "        <li>یک دنباله (مثلا رشته) یا مجموعه یا \n",
    "        dict\n",
    "        خالی: ''، \"\"، {}، []، () و غیره</li>\n",
    "    </ul>\n",
    "    هر چیز دیگری مقدار True می‌گیرد.\n",
    "</font></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"direction:rtl;line-height:300%;\" id=\"section10\"><font face=\"XB Zar\" size=5>\n",
    "<h3>حلقه‌ها</h3>\n",
    "در پایتون دو حلقه‌ی\n",
    "<span class=\"codeM\">for, while</span>\n",
    "را داریم.\n",
    "<br/>\n",
    "البته حلقه‌ی\n",
    "for\n",
    "کمی با زبان‌های دیگر متفاوت است. شما فقط می‌توانید روی یک لیست یا یک شی پیمایش‌شونده\n",
    "(iterable)\n",
    "حلقه اجرا کنید.\n",
    "<br/>\n",
    "همچنین حلقه‌ها می‌توانند یک عبارت\n",
    "<span class=\"codeM\">else</span>\n",
    "داشته باشند. اما فکر نمی‌کنم به دردتان بخورد.\n",
    "</font></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "counting .. 5\n",
      "counting .. 4\n",
      "counting .. 3\n",
      "counting .. 2\n",
      "counting .. 1\n"
     ]
    }
   ],
   "source": [
    "cnt = 5\n",
    "while cnt > 0:\n",
    "    print('counting .. ' + str(cnt))\n",
    "    cnt -= 1  # note: cnt-- or cnt++ do not work!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "5\n",
      "8\n",
      "asf\n",
      "sajf\n",
      "fsaf\n"
     ]
    }
   ],
   "source": [
    "for i in range(2, 10, 3):\n",
    "    print(i)\n",
    "\n",
    "l  = ['asf','sajf','fsaf' ]\n",
    "for i in l:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(0, 2), (1, 5), (2, 7), (3, 3), (4, 10)]\n",
      "0th value is: 2\n",
      "1th value is: 5\n",
      "2th value is: 7\n",
      "3th value is: 3\n",
      "4th value is: 10\n"
     ]
    }
   ],
   "source": [
    "l = [2, 5, 7, 3, 10]\n",
    "print(list(enumerate(l)))\n",
    "for i, value in enumerate(l):  # enumerate is like zip(0..n-1, list)\n",
    "    print('%dth value is:' % i, value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ali : 1\n",
      "mamad : 2\n",
      "(1, 2) : 4\n",
      "new : 123\n",
      "-----------\n",
      "[('ali', 1), ('mamad', 2), ((1, 2), 4), ('new', 123)]\n",
      "ali : 1\n",
      "mamad : 2\n",
      "(1, 2) : 4\n",
      "new : 123\n"
     ]
    }
   ],
   "source": [
    "for key in d:  # you can iterate dictionaries too!\n",
    "    print(key, ':', d[key])\n",
    "\n",
    "print('-----------')\n",
    "\n",
    "print(list(d.items()))\n",
    "for key, value in d.items():\n",
    "    print(key, ':', value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9135233333 iman\n",
      "9123222233 rasoul\n",
      "9212312121 fateme\n"
     ]
    }
   ],
   "source": [
    "a = [9135233333, 9123222233, 9212312121]\n",
    "b = ['iman', 'rasoul', 'fateme']\n",
    "for x, y in zip(a, b):\n",
    "    print(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"direction:rtl;line-height:300%;\" id=\"section11\"><font face=\"XB Zar\" size=5>\n",
    "<h3>Import</h3>\n",
    "یکی از قوی‌ترین جنبه‌های زبان پایتون کتابخانه‌هایی اند که برای انجام تقریبا هرگونه کاری در پایتون نوشته شده‌اند. برای استفاده از این کتابخانه‌ها ابتدا باید آن‌ها را بر روی کامپیوتر (در کتابخانه‌های نسخه‌ی پایتون خود) نصب کنید. برای این کار چند روش متداول وجود دارد:\n",
    "<ul>\n",
    "    <li>استفاده از دستور pip: <br/><div class=\"codeM english\">pip install &lt;libraryName&gt;[==version]</div></li>\n",
    "    <li>استفاده از دستور easy_install:<br/><div class=\"codeM english\">easy_install &lt;libraryName&gt;</div></li>\n",
    "    <li>دانلود کردن و setup کردن به صورت دستی: <br/><div class=\"codeM english\"># download<br/># unzip or untar<br/># cd folder<br/>python setup.py install</div></li>\n",
    "</ul>\n",
    "<br/>\n",
    "حال می‌توانید از کتابخانه‌ی مورد نظر استفاده کنید. برای این کار باید ابتدا هر کتابخانه‌ای را که می‌خواهید از آن استفاده کنید را Import (همانند include در C++) کنید و سپس از آن استفاده کنید. برای این کار چند روش وجود دارد:\n",
    "<ul>\n",
    "    <li>\n",
    "        import کردن خود ماژول:\n",
    "        <div class=\"codeM english\">\n",
    "            import urllib2 as urllib\n",
    "            <br/>\n",
    "            res = urllib.urlopen('http://ce.sharif.edu')\n",
    "        </div>\n",
    "    </li>\n",
    "    <li>\n",
    "    import کردن توابع یا کلاس‌های موجود در ماژول:\n",
    "        <div class=\"codeM english\">\n",
    "            from urllib2 import urlopen\n",
    "            <br/>\n",
    "                # or\n",
    "            <br/>\n",
    "            from urllib2 import *\n",
    "            <br/>\n",
    "            res = urlopen('http://ce.sharif.edu')\n",
    "        </div>\n",
    "    </li>\n",
    "</ul>\n",
    "بهتر است معمولا فقط از یکی از این دو روش استفاده کنیم.\n",
    "</font></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"direction:rtl;line-height:300%;\" id=\"section12\"><font face=\"XB Zar\" size=5>\n",
    "<h3>توابع</h3>\n",
    "توابع در پایتون با کلمه‌ی کلیدی\n",
    "<span class=\"codeM\">def</span>\n",
    "تعریف می‌شوند.\n",
    "<br/>\n",
    "برای ورودی دادن به تابع می توانید از همان روش ساده‌ی ورودی‌های مرتب استفاده کنید. اما می‌توانید آن‌ها را با استفاده از نام‌شان نیز مقداردهی کنید.\n",
    "<br/>\n",
    "همچنین می‌توانید توابع را همانند دیگر اشیا در متغیر‌ها ذخیره کنید یا به توابع دیگر پاس بدهید.\n",
    "<br/>\n",
    "همچنین می‌توانید در داخل یک تابع، یک تابع دیگر تعریف کنید یا توابع بی‌نام\n",
    "(anonymous function)\n",
    "داشته باشید که البته خیلی هم به دردتان نمی‌خورد.\n",
    "(توابع بی‌نام با کلمه‌ی کلیدی\n",
    "<span class=\"codeM\">lambda</span>\n",
    "تعریف می‌شوند)\n",
    "</font></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "value1: 10\n",
      "aa: salam\n",
      "bb: (2+3j)\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "def isPrime(a, b=10):\n",
    "    for i in range(2, int(math.sqrt(a)+1)):\n",
    "        if a % i == 0:\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "print(isPrime(12))\n",
    "print(isPrime(a=17))\n",
    "\n",
    "def func(value1, aa, bb):\n",
    "    print('value1:', value1)\n",
    "    print('aa:', aa)\n",
    "    print('bb:', bb)\n",
    "\n",
    "func(10, bb=2+3j, aa='salam')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n",
      "20\n"
     ]
    }
   ],
   "source": [
    "def applyFunction(f, value):\n",
    "    return f(value)\n",
    "\n",
    "def sqr(a):\n",
    "    return a*a\n",
    "\n",
    "print(applyFunction(sqr, 10))\n",
    "print(applyFunction(lambda x: 2*x, 10))  # doubles the value!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# print(isPrime('12')) -> TypeError\n",
    "isStrPrime = lambda x: isPrime(int(x))\n",
    "print(isStrPrime('12'))\n",
    "print(isStrPrime('17'))\n",
    "#  well anonymous functions are supposed to be well .. anonymous but\n",
    "# i just wanted to show that they are used just like normal functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"direction:rtl;line-height:300%;\"><font face=\"XB Zar\" size=5>\n",
    "تابع sort لیست‌ها را یادتان می‌آید؟\n",
    "می‌توانیم ترتیب مرتب‌کردن این توابع را نیز عوض کنیم.\n",
    "</font></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1', '10', '2', '4', '6']\n",
      "['1', '2', '4', '6', '10']\n"
     ]
    }
   ],
   "source": [
    "l = ['1', '6', '2', '4', '10']\n",
    "l.sort()\n",
    "print(l)  # uses string comparing methods\n",
    "\n",
    "def compareInt(str1):\n",
    "    return int(str1)\n",
    "\n",
    "l.sort(key = compareInt)\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}