الفصل الخامس-حلقات التكرار.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "2c247c2b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style type=\"text/css\">@import url('https://www.fontstatic.com/f=yassin,amiri-quran,basim-marah,b-compset');\n",
       "\n",
       "\n",
       "@font-face {\n",
       "  font-family: Arslan;\n",
       "  src: url(Arslan.ttf);\n",
       "}\n",
       "\n",
       ".title{\n",
       "direction: rtl;\n",
       "font-size:100px;\n",
       "padding-right: 15px;\n",
       "line-height:10px;\n",
       "font-family:basim-marah;\n",
       "}\n",
       "\n",
       "div.text_cell pre.CodeMirror-line {\n",
       "direction:rtl;\n",
       "font-size:20px;\n",
       "color:Blue;\n",
       "line-height:40px;\n",
       "padding-right: 1cm;\n",
       "padding-left: 1cm;\n",
       "text-align:justify;\n",
       "font-family:amiri-quran;\n",
       "}\n",
       ".rendered_html {\n",
       "direction:rtl;\n",
       "font-size:20px;\n",
       "line-height:40px;\n",
       "padding-right: 1cm;\n",
       "padding-left: 1cm;\n",
       "text-align:justify;\n",
       "font-family:amiri-quran;\n",
       "}\n",
       "\n",
       ".rendered_html p {\n",
       "direction:rtl;\n",
       "font-size:20px;\n",
       "line-height:40px;\n",
       "padding-right: 1cm;\n",
       "padding-left: 1cm;\n",
       "text-align:justify;\n",
       "font-family:amiri-quran;\n",
       "}\n",
       "\n",
       ".rendered_html h1{\n",
       "direction: rtl;\n",
       "font-size:200%;\n",
       "text-align:center;\n",
       "padding-right: 55px;\n",
       "font-family:Arslan;\n",
       "}\n",
       "\n",
       ".rendered_html h2{\n",
       "direction: rtl;\n",
       "font-size:171%;\n",
       "padding-right: 55px;\n",
       "line-height:10px;\n",
       "font-family:Arslan;\n",
       "}\n",
       "\n",
       ".rendered_html h3{\n",
       "direction: rtl;\n",
       "font-size:141%;\n",
       "padding-right: 55px;\n",
       "line-height:10px;\n",
       "font-family:Arslan;\n",
       "}\n",
       "\n",
       ".rendered_html ul {\n",
       "    list-style-type: none;\n",
       "}\n",
       "\n",
       ".rendered_html ul li:before {\n",
       "  content: '-';\n",
       "  position: absolute;\n",
       "  margin-right: -10px;\n",
       "}\n",
       "\n",
       ".arabic{\n",
       "direction:rtl;\n",
       "font-size:20px;\n",
       "line-height:40px;\n",
       "padding-right: 1cm;\n",
       "padding-left: 1cm;\n",
       "text-align:justify;\n",
       "font-family:amiri-quran;\n",
       "}\n",
       "\n",
       ".horizontal{\n",
       "height:2px;\n",
       "border:none;\n",
       "color:#333;\n",
       "background-color:#333;\n",
       "width:75%;\n",
       "}\n",
       ".jupyter-widgets{\n",
       "    font-size:20px;\n",
       "    direction:rtl;\n",
       "    margin-right:25px;\n",
       "    font-family:amiri-quran;\n",
       "        \n",
       "}\n",
       ".widget-radio-box input{\n",
       "    float:right;\n",
       "    direction:ltr;\n",
       "    margin: 0 calc( var(--jp-widgets-input-padding) * 2 ) 0 10px;\n",
       "    text-align:right;\n",
       "    height: 30px;\n",
       "}\n",
       ".widget-radio{\n",
       "    flex-direction: column;\n",
       "    width:unset;\n",
       "    \n",
       "}\n",
       ".widget-label{  \n",
       "    font-family:amiri-quran;\n",
       "    font-size:18px;\n",
       "    height: 40px;\n",
       "}\n",
       "\n",
       ".widget-radio-box label {\n",
       "    font-size:18px;\n",
       "    height: 30px;\n",
       "}\n",
       "\n",
       ".true-grade{\n",
       "    color:green;\n",
       "}\n",
       ".false-grade{\n",
       "    color:red;\n",
       "}\n",
       "label:lang(en){\n",
       "    direction:ltr;\n",
       "    text-align:right;\n",
       "}\n",
       ".s{\n",
       "    line-height:unset;\n",
       "    height:unset;\n",
       "}\n",
       ".CodeMirror-wrap {\n",
       "    font-size:16px;\n",
       "}\n",
       "\n",
       ".basic_table{\n",
       "    font-size:20px;\n",
       "    color:\"green\";\n",
       "}\n",
       "ol {\n",
       "    margin-right:25px;\n",
       "}\n",
       "\n",
       ".grid-container {\n",
       "  display: grid;\n",
       "  grid-template-columns: 50% 50%;\n",
       "  gap: 2px;\n",
       "  padding: 2px;\n",
       "}\n",
       "\n",
       ".grid-container > div {\n",
       "  text-align: center;\n",
       "  padding: 20px 0;\n",
       "  font-size: 20px;\n",
       "}</style>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import style\n",
    "style._set_css_style(\"custom.css\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "575415ac-083d-4db2-af64-6d42b46dc938",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "<hr class=horizontal>\n",
    "<center>\n",
    "<a id=\"chapter5\"></a>\n",
    "<h1 class=title>\n",
    "الفصل الخامس : حلقات التكرار\n",
    "</h1>\n",
    "</center>\n",
    "<hr class=horizontal>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "122abac1-c01e-4f74-82fd-98cdec8d2617",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "ان من اكثر بواعث الملل  ان يضطر الانسان الى اداء الاعمال ذاتها مرارا وتكرارا. وذلك لانه يرى في هذه الاعمال هدرا لوقته وجهده. فنجده قد بدأ بتحرير نفسه من قيود هذه الاعمال  باسنادها الى الات من صنعة. ومن اشهر الالات التى اعتمد عليها لاداء هذا الغرض جهاز الكمبيوتر. ونجد ان حلقات التكرار المسوؤلة عن اعداد المهام المتكررة قد اصبحت جزء رئيسي وجوهري من اجزاء معظم لغات البرمجة المشهور. وفي لغة بايثون يتم عمل المهام المتكررة بواسطة تركيبين لغويين اساسين هما حلقة for وحلقة while واللتان تعتبران المحواران الرئيسيان لهذه الفصل.  \n",
    "</div>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e47a265-8f57-4800-a2fd-3fae35615e72",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "\n",
    "<h2 class=title>\n",
    "أهداف الفصل\n",
    "</h2>\n",
    "عند اتمام هذا الفصل يجب ان يكون لديك المام بالآتي: \n",
    "\n",
    "<ol>\n",
    "<li> \n",
    "التعرف على كيفية استخدام حلقة التكرار for. \n",
    "</li>\n",
    "<li>\n",
    "التعرف على كيفية استخدام حلقة التكرار while.\n",
    "</li>\n",
    "<li>\n",
    "التعرف على مواضع التشابه والاختلاف بين مهام كل حلقة.\n",
    "</li>   \n",
    "</ol>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b5b4710-3b42-4f31-a84b-ea6fa92bd43d",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "<h2 class=title>\n",
    " حلقة التكرار\n",
    "<font color=green>for</font>\n",
    "</h2>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0073217e-6410-4036-9e7d-55832e8b60a6",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "تستخدم حلقة for التكرارية عندما يراد اداء مهمة ما عدداً معلوماً من المرات. وافضل طريقة لتفصيل التركيب اللغوي لهذه الحلقة هي اعطاء امثله توضح طريقة عملها فالمثال التالي يقوم بطباعة أحرف كلمة بايثون واحداً تلو الآخر:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "71b67010-d5f5-4cef-90b8-a84d5d3a1ad6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p\n",
      "y\n",
      "t\n",
      "h\n",
      "o\n",
      "n\n"
     ]
    }
   ],
   "source": [
    "for x in \"python\":        #  عدد مرات التكرار تم تحديده هنا بعدد احرف كلمة بايثون\n",
    "    print(x)              # المهمة التي يراد تكرارها تكتب هنا\n",
    "                          # لاحظ الفراغ الذي ترك في بداية السطر "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "501c888d-9c46-4368-9e67-3478c9fd5781",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "من المثال السابق يمكن ملاحظة الآتي :<br>\n",
    "<ol>\n",
    "<li>\n",
    "تبدأ الحلقة بكلمة for.\n",
    "</li>\n",
    "<li>\n",
    "ينتهي السطر الاول من الحلقة بنقطتين فوق بعض \":\". ويعتبر نسيان كتابة النقطتين من اشهر الاخطاء التي يقع فيها المبرمجين المبتدئين في لغة بايثون. لذلك احرص على تذكر كتابتها دائماً.\n",
    "</li>\n",
    "<li>\n",
    "لإعلام بايثون بالمهمة التي يراد تكرارها يترك فراغ في بداية السطر  بمقدار حرف واحد على الاقل  (Indentation). ومن المتعارف عليه في لغة بايثون ان يترك فراغ بمقدار 4 أحرف.\n",
    "</li>\n",
    "<li>\n",
    "يمكن كتابة المعنى الحرفي للتركيب اللغوي السابق كالاتي: \"لكل حرف يرمز اليه بالمتغير x موجود في البيان النصي \"python\" قم بطباعة قيمة x على الشاشة.    \n",
    "</li>\n",
    "<li>\n",
    "اسم المتغير هنا اختياري فيمكننا ان نستبدله باي متغير نحب فيمكننا مثلا ان نسميه letter فنحصل على نفس النتيجة كما في المثال التالي:\n",
    "</li>\n",
    "</ol>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "169b9c41-8215-463a-bd20-6d3e1c49a344",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p\n",
      "y\n",
      "t\n",
      "h\n",
      "o\n",
      "n\n"
     ]
    }
   ],
   "source": [
    "for letter in \"python\":        # عدد مرات التكرار يحدد هنا\n",
    "    print(letter)              # المهمة التي يراد تكرارها تكتب هنا\n",
    "                               # لاحظ الفراغ الذي ترك في بداية السطر "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81bed50d-54ec-404f-8ced-a8d30f26a5ba",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "إذا أردنا أن نكرر أكثر من مهمة فإنه يجب مراعاة أن يكون عدد الفراغات المتروكة في بداية سطر كل مهمة متساوياً كما في المثال التالي: \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f67f866a-8bf4-40c7-98cf-af5f298de50a",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in \"car\":        \n",
    "    print(i)\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7c9f5c4-2be2-4ccb-99c9-06d6a38c0e04",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    " عند اختلاف عدد المسافات المتروكة في بداية سطر كل مهمة فان بايثون يعطي ملاحظة على وجود خطأ كما في المثال التالي:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "810539cf-77b7-49af-a164-08708f2d8886",
   "metadata": {},
   "outputs": [],
   "source": [
    "for letter in \"car\":        \n",
    "  print(i)\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5a7b752-1c29-49fc-a8e8-baace7b1564c",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "في المثال السابق استخدمنا عدد الأحرف الموجودة في بيان نصي لتحديد عدد مرات التكرار. وهذه الطريقة ليست الوحيدة لتحديد عدد مرات التكرار فهناك البيانات التجميعية التي ذكرناها في الفصل الثالث يمكن ان نستخدمها ايضاً لتحديد عدد مرات التكرار. فالبيانات الموجودة في قائمة يمكن أن تستخدم لتحديد عدد مرات التكرار كما في المثال التالي:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c7bc342e-13a4-4991-8cf2-243e8a5dd967",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ali\n",
      "Ahmad\n",
      "Hind\n",
      "Omar\n"
     ]
    }
   ],
   "source": [
    "students=['Ali','Ahmad','Hind','Omar']\n",
    "for name in students:\n",
    "    print(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b362f5d-4b31-4b0a-a7c3-6fafeb76795e",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "لاحظ أننا استخدمنا اسم المتغير هنا ليكون name وكان بإمكاننا أن نستخدم أي اسم آخر فالعملية هنا اختيارية بحته.\n",
    "</div>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0d93a89-282d-49e1-a3ea-55b9eb2f84bb",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "وكذلك الصفوف يمكن أن تستخدام لإجراء عمليات التكرار المحدد كما في المثال التالي:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "027eab1c-9888-4847-87a9-7731441f2b4d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "for number in (1,2,3):        #استخدام الصفوف لإجراء عملية التكرار على عناصرها\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb96072b-a652-4e62-9d61-3819ec950f37",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "تعلمنا في الفصل الثالث أيضاً أن الدالتان ()keys و ()value عند استخدامها مع القواميس تعطي قائمة بالمفاتيح والقيم لذلك يمكن اجراء علميات التكرار عليها كما يلي:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c0ca70b2-90c2-4037-a5c9-29ad97e9a1b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "d={1:\"a\",2:\"b\",3:\"c\"}\n",
    "print(d.values())\n",
    "print(d.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2307ffde-188e-45ca-9340-1f4f37c7c796",
   "metadata": {},
   "outputs": [],
   "source": [
    "for value in d.values():\n",
    "    print(value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5c3af3e2-0e9c-42ea-8a95-22cfff53ea30",
   "metadata": {},
   "outputs": [],
   "source": [
    "for key in d.keys():\n",
    "    print(key)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51f6d580-f9fb-412d-a92f-f91247304076",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "كما يمكن استخدام الدالة ()range لتحديد عدد مرات التكرار وذلك لأنها تقوم بإنشاء قائمة من أعداد صحيحة كما في المثال التالي:\n",
    "</div>\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "716bff8e-8567-4bc2-a0c4-a262d5b8b7cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "for number in range(5):\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e570297-6f54-4baa-a941-6e846d0101f9",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "فالدالة ()range في الأصل تأخد ثلاث قيم من الأعداد الصحيحة اثنان منها إختياريان يمكن حذفهما كما في المثال السابق و الثالث متطلب أساسي لأنه يحدد الرقم الذي يجب أن تقف عنده قيم القائمة. فالعددان الإختياريان هما العددان الذان يحددان بداية القيمة التى تبدأ عندها القائمة والآخر يحدد عدد الخطوات التى تكون بين  قيم القائمة. \n",
    "<br>\n",
    "<br>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76de9f7e-ff49-446c-9063-642bf271f85d",
   "metadata": {},
   "source": [
    "<img src=\"img/range.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e8e816f-5004-49dc-8ca4-311d499d1a42",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "    <br>\n",
    "    فعند حذف القيم الإختيارية يفترض بايثون أنك تريد قائمة من أعداد صحيحة تبدأ من الصفر وتزيد بمقدار العدد 1.\n",
    "فالمثال السابق قام بايثون بإنتاج قائمة من أعداد الصحيحة بدأت من الصفر وتزايدت بمقدار 1 وتوقفت قبل الرقم 5. لاحظ أن العدد الذي يحدد توقف القائمة لايكون مشمولاً في القائمة. ويمكن استخدام الدالة ()range بثلاث قيم كما في المثال التالي:   \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "844c12e4-03b5-485c-8cbf-6aaf49be603b",
   "metadata": {},
   "outputs": [],
   "source": [
    "for number in range(4,10,2):\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e882527c-1d51-4a7d-9eda-b7614826d97e",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "فالقائمة السابقة بدأت بالعدد 4 و انتهت قبل العدد 10 وكان عدد الخطوات بمقدار 2.<br>كما يمكن أن يكون عدد الخطوات ذو قيمة سالبة لذلك يجب أن تكون قيمة البداية أكبر من النهاية كما في المثال التالي:\n",
    "</div>\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "575b8b17-14c8-400c-9ff9-bee3215570b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "for number in range(16,6,-3):\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "099e26b0-9f83-43d1-8766-2e3beb6fd365",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "عند استخدام قيمتين في الدالة ()range فان بايثون يفترض ان القيمة التي حذفت هي قيمة عدد الخطوات كما في المثال التالي:\n",
    "</div>\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "80af825b-e31f-4709-b221-edcf05ffc5dd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for x in range(2,5):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3662e18-0d51-4b84-bb6d-f6dbc2b55769",
   "metadata": {},
   "source": [
    "<div class=arabic><h2 class=title>تمارين استكشافية</h2></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f19bd336-22bd-42be-80d8-bf84d4a4d8fd",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "١- اكتب برانامج يقوم بطباعة الأرقام من 0 الي 10 ؟\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7825e391-703f-4f9b-ab10-9681e768f4a0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "0d9f037e-db08-4d09-b7f4-6ed9302656e5",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "٢- اكتب برنامج يقوم بطباعة الاعداد الزوجية من 50 الى 100 ؟\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7684f11b-d169-4a9f-ab9f-c20447b933a6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "5eafc666-a497-4cca-82da-3f18346ab34c",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "٣- اكتب برنامج يقوم بجمع الأعداد من 1 إلى 100 ؟\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0f22d879-b1c1-447c-bc5d-452583aec331",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "e6ec460a-cf94-4515-875e-d0806bc05a24",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "٤- اكتب برنامج يقوم بطباعة كلمة “Hello” معكوسة؟\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "acec5b37-d8de-4652-b2fc-e7234c17aeeb",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "bae38daa-956d-4491-9a39-57045129dc26",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "٥- اكتب برنامج يقوم بطباعة الأعداد الزوجية تنازلياً من 20 الي 0 ؟\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "456222eb-e040-4efc-b5b6-fec8eb81aab6",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "38dd0a7f",
   "metadata": {},
   "source": [
    "كما يمكن عمل حلقة تكرار داخل حلقة تكرار بحيث يقوم البرنامج بتكرار حلقة التكرار الداخلية عددا من المرات مساويا لعناصر حلقة التكرار الخارجية كما في المثال التالي:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2655add0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 * 1 = 1\n",
      "1 * 2 = 2\n",
      "1 * 3 = 3\n",
      "2 * 1 = 2\n",
      "2 * 2 = 4\n",
      "2 * 3 = 6\n",
      "3 * 1 = 3\n",
      "3 * 2 = 6\n",
      "3 * 3 = 9\n"
     ]
    }
   ],
   "source": [
    "for a in range(1,4):\n",
    "    for b in range(1,4):\n",
    "        print(a,\"*\",b,\"=\",a*b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd61d230",
   "metadata": {},
   "source": [
    "في المثال السابق يأخذ المتغير a لحلقة التكرار الخارجية القيمة 1 من الدالة range ومن ثم يقوم بالدخول في حلقة التكرار الداخلية الممثلة بالمتغير b حيث تتكرر اربع مرات ثم يعود البرنامج الى حلقة التكرار الخارجية ليغير قيمة a الى القيمة 2 ثم يدخل مرة اخرى في حلقة التكرار الداخلية حتى تنتهي الحلقة الداخلية ويعود مره اخرى للحلقة الخارجية وهكذا يكمل البرنامج تنفيذ الكود البرمحي حتى تنتهي عناصر القيم الموجودة في الدالة range  للحلقة الخارجية. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0327a49",
   "metadata": {},
   "source": [
    "### ايقاف حلقة التكرار قبل اكتمالها"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04deb54a",
   "metadata": {},
   "source": [
    "ان توقف حلقة التكرار الافتراضي هو الانتهاء من كافة العناصر الموجودة في قائمة او عدد الحروف الموجودة في نص. لكن في بعض الاحيان يجد المبرمج ان اكمال حلقة التكرار  لا فائدة منه (سوف نأخذ امثلة لاحقا على متى يكون اكمال حلقة التكرار لا فائدة منه ) فيعمد الي ايقاف حلقة التكرار  باستخدام عبارة التوقف break.  ولتعرف على كيفية استخدام  عبارة التوقف break سوف نفرض اننا نود ان نكتب برنامجا يقوم بطباعة كل الفواكة الموجودة في قائمة ويتوقف البرنامج عن طباعة أسماء الفواكة ويخرج من حلقة التكرار بمجرد الوصول الى فاكهة الموز كما في المثال التالي:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "811d5a14",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple\n",
      "orange\n"
     ]
    }
   ],
   "source": [
    "fruits = [\"apple\", \"orange\",\"banana\", \"cherry\"]\n",
    "for x in fruits:\n",
    "    if x == \"banana\":\n",
    "        break\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2204132",
   "metadata": {},
   "source": [
    "في المثال السابق كان لدينا قائمة باربعة فواكهة قمنا بعمل حلقة تكرار بعدد عناصرها وكان الكود البرمجي المطلوب تكراره هو التأكد من أن اسم الفاكهة المراد طباعتها ليس الموز لأنه بمجرد تحقق هذا الشرط يقوم البرنامج بتنفيذ العبارة break والتي تقوم باجبار البرنامج بالخروج من حلقة التكرار. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ec3de5b",
   "metadata": {},
   "source": [
    "إن من المناسب ان نذكر هنا ان حلقات التكرار يمكن ان تستخدم العبارة else في تركيبها اللغوي وذلك للقيام بمهام عند الانتهاء من حلقة التكرار شريطة أن حلقة التكرار لم يتم إنهائها بواسطة العبارة break. كم في المثال التالي:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6ad76e73",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "9\n",
      "loop is completed successfully\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,4):\n",
    "    print(i**2)\n",
    "else:\n",
    "    print(\"loop is completed successfully\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c8e3f9e",
   "metadata": {},
   "source": [
    "أما اذا تم إنهاء حلقة التكرار من خلال العبارة break فإن الأسطر البرمجية التي تقع داخل العبارة else لا يتم تنفيذها كما في المثال التالي:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "12439764",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple\n",
      "orange\n"
     ]
    }
   ],
   "source": [
    "fruits = [\"apple\", \"orange\",\"banana\", \"cherry\"]\n",
    "for x in fruits:\n",
    "    if x == \"banana\":\n",
    "        break\n",
    "    print(x)\n",
    "else:\n",
    "    print(\"loop is completed successfully\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da81a335",
   "metadata": {},
   "source": [
    "لنضرب الآن مثالا  آخر يوضح  الحاجة الى استخدام  break وعدم الرغبة في اكمال  حلقة التكرار. لنفرض اننا نريد كتابة برنامج يقوم بتحديد الأعداد الأولية للأرقام من 2 الى 10. الأعداد الأولية هي الأرقام التي تقبل القسمة على نفسها وعلى العدد واحد فقط. للقيام بهذه المهمة نحتاج الى كتابة الكود التالي:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "170690da",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 is a prime number\n",
      "3 is a prime number\n",
      "4 equals 2 * 2\n",
      "5 is a prime number\n",
      "6 equals 2 * 3\n",
      "7 is a prime number\n",
      "8 equals 2 * 4\n",
      "9 equals 3 * 3\n"
     ]
    }
   ],
   "source": [
    "for n in range(2, 10):\n",
    "    for x in range(2, n):\n",
    "        if n % x == 0:\n",
    "            print(n, 'equals', x, '*', n//x)\n",
    "            break\n",
    "    else:\n",
    "        print(n, 'is a prime number')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e86ffa1",
   "metadata": {},
   "source": [
    "البرنامج السابق يستخدم حلقتي تكرار واحدة داخلية والاخرى خارجية. الحلقة الخارجية تبدأ باستخدام القيمة 2 للمتغير n من الدالة  range ومن ثم تدخل في حلقة تكرار داخلية لتقوم بتحديد نوع العدد الموجود في المتغير n والذي هنا اصبح يحمل القيمة 2 للتأكد ما اذا كان العدد 2 عدد أولي او لا. طريقة التحديد تعتمد على تكوين حلقة تكرار من خلال الدالة range التي تبتدأ بالقيمة 2 وتنتهي بقيمة اقل من القيمة الموجودة في المتغير n. فعندما تكون قيمة n هي 2 فان الحلقة الداخلية سوف تتكرر صفر من المرات كما في المثال التالي:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "b01ee5ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "n=2\n",
    "for x in range(2,n):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ae1b23c",
   "metadata": {},
   "source": [
    "لاحظ ان الكود السابق لايطبع اي قيمة للمتغير x. لان عدد مرات التكرار هنا صفر."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc9dabcb",
   "metadata": {},
   "source": [
    "لذلك سوف تعتبر حلقة التكرار الداخلية انتهت بشكل كامل وسوف ينفذ الكود البرمجي الذي يقع داخل العبارة else والذي يفيد بأن قيمة العدد 2 هي عدد اولي. ويعود الكود البرمجي الى الحلقة الخارجية ليضع القيمة 3 داخل المتغير n ويكوّن حلقة تكرار داخلية جديد من الدالة range تبتدأ بالقيمة 2 وتنتهي بقيمة أقل من 3. فيتكون لدينا حلقة تكرار واحدة كما في المثال التالي:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "f44038b6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "n=3\n",
    "for x in range(2,n):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ebb4de9",
   "metadata": {},
   "source": [
    "يقوم الكود البرمجي داخل الحلقة الداخلية بالتأكد ما اذا كانت القيمة 3 للمتغير n تقبل القسمة بدون باقي على قيمة x والتي هي هنا 2  فيجد أن شرط التحقق لا يتحقق فيخرج من الحلقة الداخلية بعد اكتمالها لينفد السطر البرمجي في العبارة else كما شرحنا سابقاً.  تتكرر العملية بالذهاب الى الحلقة الخارجية وإعطاء n القيمة 4 ويتم تكوين حلقة تكرارية جديد من خلال الدالة range تبدأ من 2  وتنتهي  بـقيمة أقل من 4 فيتكون لدينا حلقتي تكرار كما في المثال التالي:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "095039b4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "n=4\n",
    "for x in range(2,n):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0737762",
   "metadata": {},
   "source": [
    "يقوم الكود البرمجي داخل الحلقة الداخلية بالتأكد ما اذا كانت القيمة 4 للمتغير n تقبل القسمة بدون باقي على قيمة x والتي تبدأ اولا بـ 2 فيجد أن شرط التحقق يتحقق فيبدأ تنفيذ السطر البرمجي المحكوم بتحقق الشرط وهو طباعة حاصل ضرب القيمة x بقيمة حاصل قسمة n بالقيمة x ثم يتم استدعاء العبارة break للخروج من حلقة التكرار الداخلية لأنه لا يوجد داعي للتحقق من كون قيمة x الثانية هي قاسم للعدد 4 فيكفي وجود قيمة واحدة غير العدد نفسه لأثبات أن العدد غير أولي. سوف يعود الكود البرمجي بعدها الى الحلقة الخارجية دون تنفيذ السطر البرمجي للعبارة else لأن حلقة التكرار تم انهاؤها قبل أن تكتمل. تتكرر العملية بالذهاب الى الحلقة الخارجية  على هذا المنوال حتى تنتهي عناصر الحلقة الخارجية.  كلما زادت قيمة n كلما زاد عدد مرات التكرار التي يتخطاها الكود البرمجي بالعبارة break فيصبح تنفيذ الكود أسرع مقارنة بكود برمجي يقوم بنفس المهمة دون استخدام العبارة break. لإثبات هذه المعلومة لنقم بكتابة الكود البرمجي السابق بدون استخدام عبارة break  بحيث يتطلب الخروج من الحلقة الداخلية إكمال جميع الحلقات التكرارية كما في المثال التالي:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "20ef00f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%timeit\n",
    "prime=[]\n",
    "non_prime=[]\n",
    "for n in range(2, 10000):\n",
    "    divisor=0\n",
    "    for x in range(2, n):\n",
    "        if n % x == 0:\n",
    "            divisor+=1\n",
    "    if divisor:\n",
    "        non_prime.append(n)\n",
    "    else:\n",
    "        prime.append(n)\n",
    "print(\"prime=\",len(prime))\n",
    "print(\"non-prime=\",len(non_prime))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e276ad52",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%timeit\n",
    "prime=[]\n",
    "non_prime=[]\n",
    "for n in range(2, 10000):\n",
    "    for x in range(2, n):\n",
    "        if n % x == 0:\n",
    "            non_prime.append(n)\n",
    "            break\n",
    "    else:\n",
    "        prime.append(n)\n",
    "print(\"prime=\",len(prime))\n",
    "print(\"non-prime=\",len(non_prime))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e528c7c",
   "metadata": {},
   "source": [
    "### استخدام عبارة المواصلة continue"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1dc21a80",
   "metadata": {},
   "source": [
    "تسخدم العبارة continue داخل حلقات التكرار عندما يرغب المبرمج في عدم تنفيذ الاسطر البرمجية التي تلي العبارة continue  بحيث يذهب البرنامج الى تنفيذ الحلقة التكرارية التالية كما هو موضح في المثال التالي:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "1a6a3ca9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple\n",
      "cherry\n"
     ]
    }
   ],
   "source": [
    "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
    "for x in fruits:\n",
    "    if x == \"banana\":\n",
    "        continue\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d31345bf",
   "metadata": {},
   "source": [
    "فحلقة التكرار السابقة تحتوي على شرط عند تحققه فإن البرنامج يتخطى باقي الاسطر البرمجية التي تقع داخل الحلقة التكرارية والتي هي هنا امر الطباعة ويذهب الى تنفيذ الحلقة التكرارية التالية. فعند تحقق الشرط بأن تكون قيمة x تساوي  banana فإن البرنامج تخطى امر طباعة  banana ويذهب للحلقة التي بعدها تضع قيمة x  بالقيمة  cherry وعند عدم تحقق الشرط فان امر طباعة  cherry  يتحقق."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41745e4d",
   "metadata": {},
   "source": [
    "### استخدام حلقة التكرار لإنشاء القوائم"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06330fd6",
   "metadata": {},
   "source": [
    "هناك طريقتان شائعتان لإنشاء القوائم بواسطة حلقات التكرار:\n",
    "\n",
    "**الطريقة المطولة**: تعتمد على إنشاء قائمة فارغة ومن ثم استخدام الامر append لاضافة العناصر لهذه القائمة كما في المثال التالي:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "5f947301",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apple', 'banana', 'mango']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruits = [\"apple\", \"banana\", \"cherry\", \"kiwi\", \"mango\"]\n",
    "newlist = []\n",
    "\n",
    "for x in fruits:\n",
    "    if \"a\" in x:\n",
    "        newlist.append(x)\n",
    "newlist"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7963221a",
   "metadata": {},
   "source": [
    "**الطريقة المختصرة**: تعتبر هذه الطريقة هي الاكثر شيوعاً والمفضلة لدى المبرمجين لأنها تسمح بإنشاء القائمة من خلال كتابة سطر برمجي واحد فقط. فلو أردنا ان نكتب المثال السابق بالطريقة المختصرة لأصبح الكود بالشكل التالي:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "8cde44c5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apple', 'banana', 'mango']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruits = [\"apple\", \"banana\", \"cherry\", \"kiwi\", \"mango\"]\n",
    "newlist = [x for x in fruits if \"a\" in x]\n",
    "newlist"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0bad43f8-b5d4-4ac2-8597-98547113fe85",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "<h2 class=title>\n",
    " حلقة تكرار\n",
    "<font color=green>while</font>\n",
    "</h2>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3243b2c0-f62a-49a9-9b13-eb7dd834f2da",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "الحلقة التكرارية while تستخدم عندما يكون عدد مرات التكرار التي يريد المبرمج القيام بها غير معروف مسبقاً. لذلك تستخدم هذه الحلقة التكرارية عندما نريد أن نقوم بعمليات تكرار غير منتهية أو عندما لا يتم معرفة إمكانية الخروج من الحلقة التكرارية إلا بعد اجراء بعض العمليات داخل الحلقة التكرارية. ويكون التركيب اللغوي لهذه الحلقة مشابها لحد ما لحلقة for كما في المثال التالي:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a7732d7e-b36d-4bdb-b70d-16d8ed845277",
   "metadata": {},
   "outputs": [],
   "source": [
    "a=1\n",
    "while a<10:\n",
    "    print(a)\n",
    "    a=a+2  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56d2fe52-76b5-463e-9176-fd473d90657f",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "من المثال السابق يتضح الآتي:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ebdaae1-595f-4b1e-adcc-9b00f1d91472",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "<ol>\n",
    "    <li>\n",
    "    تبدأ حلقة التكرار بكلمة while.\n",
    "    </li>\n",
    "    <li>\n",
    "    استمرارية حلقة التكرار يكون محكوماً بالشرط الذي يتلو كلمة while.\n",
    "    </li>\n",
    "    <li>\n",
    "    ينتهي السطر الاول من الحلقة بنقطتين فوق بعض \":\".\n",
    "    </li>\n",
    "    <li>\n",
    "    يترك مسافة بمقدار حرف واحد على الأقل (Indentation) قبل كتابة الأوامر التي يراد تكرارها.  ومن المتعارف عليه في لغة بايثون أن يترك فراغ بمقدار 4 أحرف.\n",
    "    </li>\n",
    "</ol>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00f766dd-16bf-40d9-b15b-6eb1a93554c9",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "يمكن كتابة المعنى الحرفي للمثال السابق على النحو التالي: \"طالما قيمة a  أقل من 10 قم بتكرار طباعة القيمة a\".\n",
    "    <br>\n",
    "    وبما أن قيمة a  تتزايد داخل حلقة التكرار بمقدار 2 في كل مرة فإن طباعة القيمة الجديدة لـ a سوف تتكرر الى أن ينتفي شرط تحقق الحلقة. عندها يتم الخروج من حلقة التكرار while وتتوقف طباعة قيم a. تمعن في الشكل التالي لفهم ما يقوم به مفسر بايثون داخل حلقة while. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f104116-f56f-42de-9f9c-b5c6eb8c3558",
   "metadata": {},
   "source": [
    "<img src=\"https://blog.penjee.com/wp-content/uploads/2015/03/while-loop-animation-python.gif\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c81d7f62",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "ماذا تتوقع ان يحدث لو قمنا بحذف السطر الرابع من الكود السابق بحيث تظل قيمة a بدون تغيير. ربما قد هداك تفكيرك اذا كان سليماً الى اننا سوف نحصل على حلقة تكرار غير منتهية تقوم بطباعة قيمة a الى ما لا نهاية عندها سوف يتوقف مفسر بايثون من اداء اي مهام اخرى وسوف تضطر الى الضغط على زر الايقاف الاجباري (زر المربع الاسود الموجود فس شريط الادوات) لايقاف عملية الطباعة او الضغط مرتين متتاليتين على حرف i من لوحة المفاتيح او اختيار interrupt من قائمة Kernel. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51ad99ab",
   "metadata": {},
   "source": [
    "<div class=arabic><h2 class=title>تمارين استكشافية</h2></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e111029",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "1. قم بكتابة الكود البرمجي السابق بعد حذف السطر الأخير ولاحظ كيف تتم طباعة القيمة a. حاول ايقاف علمية الطباعة باستخدام أحد الطرق السابقة.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "053820e7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f9e45861",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "2. حاول أن تتعرف على ما إذا كان الكودين البرمجيين التاليين سوف ينتج عنهما حلقة تكرار منتهية أو غير منتهية بدون تشغيل الكود. بعد أن تكون قد حددت إجابتك قم بتشغيل الكود لمعرفة الإجابة الصحيحة؟.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0840718",
   "metadata": {},
   "outputs": [],
   "source": [
    "# الكود الاول\n",
    "n = 1\n",
    "while n > 0:\n",
    "    n /= 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "997f736d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# الكود الثاني\n",
    "n = 2\n",
    "while n > 0:\n",
    "    if n % 2 == 0:\n",
    "        n += 1\n",
    "    else:\n",
    "        n -= 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3213672",
   "metadata": {},
   "source": [
    "كما يمكن استخدام العبارة break مع حلقة التكرار while كما فعلنا من قبل مع حلقة التكرار for كما في المثال التالي:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b6aa9839",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "while i < 6:\n",
    "    print(i)\n",
    "    if i == 3:\n",
    "        break\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "727a97c5",
   "metadata": {},
   "source": [
    "واستخدام عبارة  else سوف يكون بنفس الطريقة التي تعلمناها مع حلقة التكرار كما في المثالين التاليين:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "435fbe8e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "while i < 6:\n",
    "    print(i)\n",
    "    if i == 3:\n",
    "        break\n",
    "    i += 1\n",
    "else:\n",
    "    print(\"I completed the loop successfully\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "8c7972ac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "I completed the loop successfully\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "while i < 6:\n",
    "    print(i)\n",
    "    if i == 13:\n",
    "        break\n",
    "    i += 1\n",
    "else:\n",
    "    print(\"I completed the loop successfully\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "daccb2e7",
   "metadata": {},
   "source": [
    "وكذلك استخدام العبارة continue يمكن استخدامها مع حلقة تكرار  while بنفس الطريقة التي تعلمناها مع حلقة التكرار  for كما في المثال التالي:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f40d62b2",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "4\n",
      "5\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i < 6: \n",
    "    i += 1    \n",
    "    if i == 3:\n",
    "        continue\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62a4580e",
   "metadata": {},
   "source": [
    "### استخدام دالة ادخال البيانات ()input مع حلقة التكرار while"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9488a199",
   "metadata": {},
   "source": [
    "يكثر استخدام  حلقة التكرار while مع دالة الادخال ()input والتي تطلب من مستخدم البرنامج ادخال البيانات التي يحتاجها البرنامج لاتمام العمليات المطلوبة من البرنامج. فعلى سبيل المثال يمكن كتابة برنامج يطلب من المستخدم ادخال قيمة نصية بحيث يقوم البرنامج بطباعة عدد أحرف القيمة النصية التي ادخلها المستخدم. لتمكين المستخدم من ادخال قيم نصية مختلفة في كل مرة نستخدم حلقة التكرار while بحيث نطلب من المستخدم ادخال قيمة اخرى لحساب عدد حروفها وطباعتها على الشاشة. سوف تستمر هذا العملية الى ما لا نهاية لذلك يفضل ان يعمل شرط داخل حلقة التكرار while بحيث في حال تحققه يقوم بالخروج من الحلقة التكرارية كما هو موضح في البرنامج التالي: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "39ad8e95",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "please enter a text otherwise write q to quit: hello\n",
      "You entered  5  letters\n",
      "please enter a text otherwise write q to quit: my name is a ahmad\n",
      "You entered  18  letters\n",
      "please enter a text otherwise write q to quit: q\n"
     ]
    }
   ],
   "source": [
    "\n",
    "while True:\n",
    "    txt=input(\"please enter a text otherwise write q to quit: \")\n",
    "    if txt==\"q\":\n",
    "        break\n",
    "    else: print(\"You entered \",len(txt),\" letters\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "420a8300",
   "metadata": {},
   "source": [
    "للاستزادة حول استخدام الدالة ()input يمكنك  قراءة الفصل السابع من هذا الكتاب."
   ]
  }
 ],
 "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}