05_SyntaxLearn_Control_Iteration.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "aa858869-cab0-4e71-9458-2a39c72bdcd8",
   "metadata": {},
   "source": [
    "# حلقه While"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e1112af6-f1bf-415a-b748-2725bdec7a5c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "x :  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6, 8, "
     ]
    }
   ],
   "source": [
    "# While\n",
    "n = int(input(\"x : \")) # نقطه شروع\n",
    "\n",
    "while n<10:\n",
    "    if n%2 == 0:\n",
    "        print(n, end=\", \")\n",
    "    n += 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "42116e4b-39d5-4efb-832b-5e4b0b810702",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "x is :  24\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x : {1, 2, 3, 4, 6, 8, 12, 24, }\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "x is :  12\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x : {1, 2, 3, 4, 6, 12, }\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "x is :  18\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x : {1, 2, 3, 6, 9, 18, }\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "x is :  36\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x : {1, 2, 3, 4, 6, 9, 12, 18, 36, }\n"
     ]
    }
   ],
   "source": [
    "# چاپ مقسوم علیه های یک عدد دلخواه\n",
    "temp = 0\n",
    "while temp < 4:\n",
    "    x = int(input(\"x is : \"))\n",
    "    count = 1\n",
    "    print(\"x : {\", end = (''))\n",
    "    while count <= x:\n",
    "        if x%count == 0:\n",
    "            print(count, end = (', '))\n",
    "        count += 1\n",
    "    print(\"}\")\n",
    "    temp += 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "40ff99cf-6057-4164-a06c-b5511fd1e83c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "1\n",
      "2\n",
      "3\n",
      "5\n",
      "8\n",
      "13\n",
      "21\n",
      "34\n",
      "55\n",
      "89\n",
      "144\n",
      "233\n",
      "377\n",
      "610\n",
      "987\n",
      "1597\n",
      "2584\n",
      "4181\n"
     ]
    }
   ],
   "source": [
    "# 0,1,1,2,3,5,8,13,21,34,... سری فیبوناچی\n",
    "a, b = 0, 1\n",
    "i = 1\n",
    "while i <= 20:\n",
    "    print(a)\n",
    "    a, b = b, a+b  # اگر در دو خط جدا بنویسیم اشتباه میشود   مقدار دهی بصورت همزمان انجام میشود\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c790273b-eea6-421f-9558-0e41f7f097b9",
   "metadata": {},
   "source": [
    "## دستور Break\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e4122bdf-35b6-41a9-bca5-af708b5dc1d4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, end of code\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "while i<= 20:\n",
    "    print(i,end=\", \")\n",
    "    if i == 10: \n",
    "        break # از حلقه بیرون می پرد، نزدیک ترین حلقه\n",
    "    i += 1\n",
    "print(\"end of code\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f828ed06-a11a-4934-856b-8e68a1efab1b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "n:  12.4\n",
      "Do you want to conitnue?  yes\n",
      "n:  36.124\n",
      "Do you want to conitnue?  yes\n",
      "n:  2.647\n",
      "Do you want to conitnue?  no\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.647 is smallest number!\n"
     ]
    }
   ],
   "source": [
    "# کنترل حلقه بی نهایت با break\n",
    "m = float(\"inf\")\n",
    "while True:\n",
    "    n = float(input(\"n: \"))\n",
    "    if n<m:\n",
    "        m = n\n",
    "    s = input(\"Do you want to conitnue? \")\n",
    "    if s.lower() == \"no\": # بررسی رشته با حروف کوچک\n",
    "        break\n",
    "\n",
    "print(m, \"is smallest number!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b75ef804-3673-4848-8d75-f331da4b293d",
   "metadata": {},
   "source": [
    "## دستور continue برای ادامه ندادن دستورات حلقه\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b69449d0-a7db-4984-8756-d158f2e0bc36",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "4\n",
      "5\n",
      "7\n",
      "8\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "# دستورات بعد کنتینیو اجرا نشده و حلقه از ابتدا شروع به اجرا دستورات میکند\n",
    "i = 0\n",
    "while i<10:\n",
    "    i += 1\n",
    "    if i % 3 == 0:\n",
    "        continue\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "503563e3-63a8-4800-b153-5d2cbcb334ed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "n:  ۱۲\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12 is Not a prime number!\n"
     ]
    }
   ],
   "source": [
    "# else  زمانیکه بریک و خطایی رخ ندهد   در حلقه وایل برای بررسی اتمام بدون شکست حلقه\n",
    "# در شرایطی که حلقه بدون بریک اتمام یابد دستورات الس اجرا می شود\n",
    "n = int(input(\"n: \"))\n",
    "i = 2\n",
    "if n>1:\n",
    "    while i<n:\n",
    "        if n % i == 0:\n",
    "            print(n, \"is Not a prime number!\")\n",
    "            break\n",
    "        i += 1\n",
    "    else:\n",
    "        print(n, \"Is a prime number.\")\n",
    "else:\n",
    "    print(n, \"is Not a prime number!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "dde4b2c8-374d-4b18-9a0b-50ce4f1e329f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\t 1\n",
      "\t 2\n",
      "\t 3\n",
      "\t 4\n",
      "\t 5\n",
      "1\n",
      "\t 1\n",
      "\t 2\n",
      "\t 3\n",
      "\t 4\n",
      "\t 5\n",
      "2\n",
      "\t 1\n",
      "\t 2\n",
      "\t 3\n",
      "\t 4\n",
      "\t 5\n",
      "3\n",
      "\t 1\n",
      "\t 2\n",
      "\t 3\n",
      "\t 4\n",
      "\t 5\n",
      "4\n",
      "\t 1\n",
      "\t 2\n",
      "\t 3\n",
      "\t 4\n",
      "\t 5\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# nested loop\n",
    "i = 1\n",
    "while i <= 5:\n",
    "    j = 1\n",
    "    while j <= 5:\n",
    "        print(\"\\t\" , j)\n",
    "        j += 1\n",
    "    print(i)\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "539b6590-24c1-486b-9f3d-cda6fb35668f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\t 1\n",
      "\t 2\n",
      "\t 3\n",
      "\t 4\n",
      "\t 5\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "j = 1\n",
    "while i <= 5:\n",
    "    while j <= 5:\n",
    "        print(\"\\t\" , j)\n",
    "        j += 1\n",
    "    print(i)\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "fadf3d38-1564-47ea-95bd-2e77c3938bdd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AlI\n",
      "AmIr\n"
     ]
    }
   ],
   "source": [
    "l = [\"ali\" , \"amir\"]\n",
    "i = 0\n",
    "while i < len(l):\n",
    "    s = l[i]\n",
    "    j = 0\n",
    "    while j < len(s):\n",
    "        if j % 2 == 0:\n",
    "            print(s[j].upper() , end=\"\")\n",
    "        else : \n",
    "            print(s[j], end=\"\")\n",
    "        j += 1\n",
    "    print() #for space between words\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "151dc0b7-4109-47a4-8242-1b74d101c848",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\t2\t3\t4\t5\t6\t7\t8\t9\t10\t\n",
      "2\t4\t6\t8\t10\t12\t14\t16\t18\t20\t\n",
      "3\t6\t9\t12\t15\t18\t21\t24\t27\t30\t\n",
      "4\t8\t12\t16\t20\t24\t28\t32\t36\t40\t\n",
      "5\t10\t15\t20\t25\t30\t35\t40\t45\t50\t\n",
      "6\t12\t18\t24\t30\t36\t42\t48\t54\t60\t\n",
      "7\t14\t21\t28\t35\t42\t49\t56\t63\t70\t\n",
      "8\t16\t24\t32\t40\t48\t56\t64\t72\t80\t\n",
      "9\t18\t27\t36\t45\t54\t63\t72\t81\t90\t\n",
      "10\t20\t30\t40\t50\t60\t70\t80\t90\t100\t\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "while i <= 10:\n",
    "    j = 1\n",
    "    while j <= 10:\n",
    "        print(i*j, end=\"\\t\")\n",
    "        j += 1\n",
    "    print() # for next line\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2891b3f-921d-4305-a117-05bb05383654",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6451e4b4-7443-4130-925e-d47a8462c924",
   "metadata": {},
   "source": [
    "# حلقه For"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "694962a6-d72c-419e-8264-51c555cf46a0",
   "metadata": {},
   "source": [
    "در سی پلاس پلاس حلقه فور و حلقه وایل به یک شکل عمل می کنند"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95bca7b0-6cf3-49a7-848c-1f322a30ee4c",
   "metadata": {},
   "source": [
    "عملکرد حلقه فور در پایتون با عملکرد آن در زبان های دیگر متفاوت است و کاربرد بهتری دارد"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ff30fef-0bba-411c-9e62-051dea1fbb8e",
   "metadata": {},
   "source": [
    "در پایتون یک.حلقه فور زمانی استفاده می شود که بخواهیم روی توالی ها (لیست، رشته و تاپل) کار کنیم"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "4fc0a9f8-4a4c-46ae-a692-1d5b0881470c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1,2,3,4,5,6,7,8,\n",
      "s,a,l,a,m,"
     ]
    }
   ],
   "source": [
    "# for target in object:\n",
    "\n",
    "list1 = [1,2,3,4,5,6,7,8]\n",
    "\n",
    "for i in list1: # در هر تکرار شمارنده آی یکی از اعضای لیست است\n",
    "    print(i, end = \",\")\n",
    "\n",
    "print()\n",
    "\n",
    "str1 = \"salam\"\n",
    "for ch in str1:\n",
    "    print(ch, end = \",\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9a08314-b4ae-4db0-9ec1-4a486437bcb8",
   "metadata": {},
   "source": [
    "دو.از حلقه فور زمانی استفاده می شود که تعداد تکرار ها معلوم و از حلقه وایل در شرایط استفاده می شه که تعداد تکرار مشخص نباشه"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "52f38beb-be65-4c92-8e62-ce11de13646c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# break else continue همان کاربرد حلقه وایل را نیز در حلقه فور دارند"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "74c8dcab-58fa-4cc7-a535-f79263acf7d8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "12\n"
     ]
    }
   ],
   "source": [
    "list1 = [1,3,6,9,12,15]\n",
    "list2 = [0,2,4,6,8,10,12]\n",
    "\n",
    "for i in list1:\n",
    "    for j in list2:\n",
    "        if i == j:\n",
    "            print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "34647764-45ad-49ce-a9ab-4d6fc2076af8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n",
      "4 5 6\n",
      "7 8 9\n"
     ]
    }
   ],
   "source": [
    "for a,b,c in [[1,2,3], [4,5,6], [7,8,9]]:\n",
    "    print(a,b,c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "54f58803-469e-442a-b6ff-68303972613b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a : 1\n",
      "b : 2\n",
      "c : 3\n"
     ]
    }
   ],
   "source": [
    "d = {'a':1, 'b':2, 'c':3}\n",
    "for key, value in d.items():\n",
    "    print(key, ':', value)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eadb5787-c0fe-4547-a532-c6f8c38f7d07",
   "metadata": {},
   "source": [
    "## range کاربرد در حلقه فور"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "7e7d0fd0-d5ca-460e-831b-d70af17bc722",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'range'>\n",
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "******************************\n",
      "0-1-2-3-4-\n",
      "******************************\n",
      "2-3-4-5-6-7-8-9-\n",
      "******************************\n",
      "0-3-6-9-12-15-18-21-24-27-30-\n",
      "******************************\n",
      "-20\t-33\t-46\t-59\t-72\t-85\t-98\t-111\t-124\t"
     ]
    }
   ],
   "source": [
    "print(type(range(10)))\n",
    "print(list(range(10))) # از صفر شروع می شود و خود 10 شامل نمی شود\n",
    "print('*'*30)\n",
    "\n",
    "for i in range(5):\n",
    "    print(i, end = \"-\")\n",
    "print()\n",
    "print('*'*30)\n",
    "\n",
    "for i in range(2,10): # از 2 شروع می شود تا 10\n",
    "    print(i, end = \"-\") \n",
    "print()\n",
    "print('*'*30)\n",
    "\n",
    "for i in range(0,31,3): # عدد 3 گام رنج هست\n",
    "    print(i, end = \"-\") \n",
    "print()\n",
    "print('*'*30)\n",
    "for i in range(-20, -131, -13):  \n",
    "    print(i, end = \"\\t\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "a4d1abbc-609f-4e89-a2a3-4081ebf532b7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "n :  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "f = 120\n"
     ]
    }
   ],
   "source": [
    "# مثال فاکتوریل\n",
    "n = int(input(\"n : \"))\n",
    "f = 1 # Initial value\n",
    "\n",
    "for i in range(1, n+1):\n",
    "    f *= i\n",
    "print(\"f =\", f)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "c48acc85-421d-42c9-8dcb-34edbc5afcb2",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "n is :  123456789\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "987654321"
     ]
    }
   ],
   "source": [
    "#مثال برعکس نوشتن یک عدد\n",
    "n = input('n is : ') # دریافت بصورت رشته\n",
    "for i in range(len(n)-1, -1, -1):\n",
    "    print(n[i], end=\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "03ef1733-30cc-4575-b579-9c6eb5d3dfa8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<enumerate object at 0x000002647AC31B80>\n",
      "[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]\n",
      "0 : a\n",
      "1 : b\n",
      "2 : c\n",
      "3 : d\n"
     ]
    }
   ],
   "source": [
    "#enumerate\n",
    "l = ['a','b','c','d']\n",
    "print(enumerate(l))\n",
    "print(list(enumerate(l)))\n",
    "for i,j in enumerate(l):\n",
    "    print(i, \":\", j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "ec54ee84-c941-4d35-9ac7-8ca4cf4597f3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name: reaz . age: 13\n",
      "name: ali . age: 35\n",
      "name: neda . age: 26\n",
      "name: mina . age: 41\n"
     ]
    }
   ],
   "source": [
    "#zip در حلقه for\n",
    "x = [\"reaz\",\"ali\",\"neda\",\"mina\"]\n",
    "y = [13, 35, 26, 41]\n",
    "\n",
    "for i, j in zip(x,y):\n",
    "    print(\"name:\", i, \". age:\", j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "7f332d77-db81-44d5-84b4-211e2370a356",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "3\n",
      "2\n",
      "1\n",
      "******************************\n",
      "72\n",
      "56\n",
      "32\n",
      "23\n",
      "14\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# معکوس کردن حرکت با reversed\n",
    "l = [1,2,3,4]\n",
    "for i in reversed(l):\n",
    "    print(i)\n",
    "print('*'*30)\n",
    "\n",
    "# مرتب کردن لیست در حلقه با sorted\n",
    "\n",
    "l2 = [23,32,14,56,72,9]\n",
    "for i in sorted(l2, reverse=True):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1228f343-9633-45d4-a9e9-fbf487a24b52",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "ce4ff746-dc5e-464a-82b8-28db90923f4e",
   "metadata": {},
   "source": [
    "# اعداد تصادفی Random (شبه تصادفی)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "c896580f-d707-4cd7-9bc9-3eba1477ce6e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8495821014177612\n"
     ]
    }
   ],
   "source": [
    "import random # نیازمند وارد کردن ماژول مرتبط\n",
    "print(random.random()) #تولید عدد تصادفی بین باز صفر تا یک\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "a12f8012-3f46-4e17-94a2-c2bb5971b847",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9248652516259452\n",
      "0.9486057779931771\n",
      "0.8924333440485793\n",
      "0.08355067683068362\n"
     ]
    }
   ],
   "source": [
    "# seed در اعداد تصادفی\n",
    "# با تعیین seed همیشه عدد تصادفی مرتبط با آن تولید می شود\n",
    "from random import random, seed\n",
    "seed(23)\n",
    "print(random())\n",
    "print(random())\n",
    "print(random())\n",
    "print(random())\n",
    "# وقتی ما سید نمی دهیم، زمان که هر لحظه متغیر است به عنوان سید در نظر گرفته می شود"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "66f9812c-3729-44a5-a8f2-c7d6be64973d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8.104957275690335\n",
      "9.853676137894785\n",
      "6.813962592390542\n",
      "8.798933061217655\n",
      "6.843419073841034\n",
      "7.860233905958904\n",
      "******************************\n",
      "8\n",
      "6\n",
      "5\n",
      "7\n",
      "******************************\n",
      "10\n",
      "8\n",
      "9\n",
      "8\n",
      "******************************\n",
      "5\n",
      "5\n",
      "5\n",
      "8\n",
      "******************************\n",
      "e\n",
      "b\n",
      "e\n",
      "******************************\n",
      "['a', 'e']\n",
      "******************************\n",
      "['c', 'b', 'e', 'd', 'a']\n"
     ]
    }
   ],
   "source": [
    "# عدد تصادفی در بازه\n",
    "# فرمول low + rand*(up - low)\n",
    "from random import random\n",
    "for _ in range(6): # از _ معمولا وقتی که استفاده ای از شمارنده نمی شود استفاده می شود\n",
    "    print(5 + random()*(10-5)) # بازه 5 تا 10\n",
    "print(\"*\"*30) # *****************************************************************************\n",
    "\n",
    "# متد uniform\n",
    "import random\n",
    "for _ in range(4):\n",
    "    print(int(random.uniform(5,10))) # استفاده از یونیفورم برای تعیین بازه برای رندوم و اینت برای حذف اعشار\n",
    "    # خود 10 وانتهای بازه نخواهد بود\n",
    "print(\"*\"*30) # *****************************************************************************\n",
    "\n",
    "for _ in range(4):\n",
    "      print(random.randint(5,10)) # متدی برای تولید اعداد تصادفی صحیح و خود انتهای بازه هم می تواند باشد\n",
    "print(\"*\"*30) # *****************************************************************************\n",
    "\n",
    "for _ in range(4):\n",
    "      print(random.randrange(5,10,3)) #  گام هم میتونیم تعیین بکنیم ـ متدی برای تولید اعداد تصادفی صحیح و خود انتهای بازه هم می تواند باشد\n",
    "print(\"*\"*30) # *****************************************************************************\n",
    "\n",
    "l = ['a','b','c','d','e']\n",
    "for _ in range(3):\n",
    "      print(random.choice(l)) # انتخاب تصادفی از بین لیست\n",
    "print(\"*\"*30) # *****************************************************************************\n",
    "\n",
    "print(random.sample(l,2)) # از لیست یک نمونه تصادفی تولید می کند\n",
    "print(\"*\"*30) # *****************************************************************************\n",
    "\n",
    "random.shuffle(l) # ترتیب خود لیست را تصادفی تغییر می دهد و بُر میزند\n",
    "print(l)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "79bdfdf7-3a07-4ce5-b1b7-ade841fd5c40",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 1684, 2: 1690, 3: 1637, 4: 1627, 5: 1680, 6: 1682}\n"
     ]
    }
   ],
   "source": [
    "# مثال تاس\n",
    "from random import randint\n",
    "tas = {1:0, 2:0, 3:0, 4:0, 5:0, 6:0} # مقدار اولیه برای هر رویداد تاس\n",
    "\n",
    "for _ in range(10000):\n",
    "    tas[randint(1,6)] += 1\n",
    "\n",
    "print(tas)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab081b89-e6d4-47fd-8555-a2d87234d070",
   "metadata": {},
   "source": [
    "از numpy هم می توان اعداد تصادفی تولید کرد که نیازمند نصب هست تا بتوان ایمپورت کرد"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "1478e5b7-f0a1-4206-94bd-95f11287dbf7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "x : 23\n",
      "y : 23\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23\n",
      "******************************\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "x : 23\n",
      "y : 23\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23\n"
     ]
    }
   ],
   "source": [
    "# بزرگترین مقسوم علیه مشترک\n",
    "x = int(input('x :'))\n",
    "y = int(input('y :'))\n",
    "\n",
    "min_ = min(x , y)\n",
    "tem = 0\n",
    "for i in range(1 , (min_+1)):\n",
    "    if (x%i == 0) and (y%i == 0):\n",
    "        if i > tem :\n",
    "            tem = i\n",
    "            \n",
    "print(tem)\n",
    "\n",
    "print('*'*30)\n",
    "\n",
    "\n",
    "# بزرگترین مقسوم علیه مشترک\n",
    "x = int(input('x :'))\n",
    "y = int(input('y :'))\n",
    "\n",
    "min_ = min(x , y)\n",
    "for i in range(min_ , 0 , -1):\n",
    "    if (x%i == 0) and (y%i == 0):\n",
    "        print(i)\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "2f30b645-b6a5-4a5c-8b9d-e671661b21d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "e is your choice?(y/n) \n",
      "a is your choice?(y/n) y\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "you done!\n"
     ]
    }
   ],
   "source": [
    "from random import choice\n",
    "name = ['a' , 'e' , 'r' , 't' , 'y']\n",
    "name_cop = name.copy()\n",
    "\n",
    "while True : \n",
    "    if len(name_cop) == 0: \n",
    "        break\n",
    "    cmp_choice = choice(name_cop)\n",
    "    ans = input(f\"{cmp_choice} is your choice?(y/n)\")\n",
    "    if ans == \"y\":\n",
    "        print(\"you done!\")\n",
    "        break\n",
    "    name_cop.remove(cmp_choice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a2121e84-dcde-4bc2-a5d1-8dda613f6a58",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}