الفصل السادس-كتابة الدوال.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "5e81aa29",
   "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": "72a10d25",
   "metadata": {},
   "source": [
    "# الفصل السادس : كتابة الدوال\n",
    "<hr class=horizontal>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e82b7f66-d185-4134-9a06-30e65d6fbf5e",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "في هذا الفصل سوف نتطرق الى معرفة الدوال والتي هي عبارة عن أكود برمجية مستقلة يمكن استدعاءها متى واينما شاء المبرمج. الغرض الأساسي من استخدامها يكمن في تجزئة البرنامج الى أجزاء صغيرة تساعد المبرمج على عدم تكرار الأكواد داخل البرنامج وتسهل عليه عملية إصلاح الأخطاء.\n",
    "</div>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f6b3e4d",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "\n",
    "## أهداف الفصل\n",
    "عند إتمام هذا الفصل يجب أن يكون لديك إلمام بالآتي: \n",
    "<ol>\n",
    "<li> \n",
    "كيفية كتابة دالة وطريقة استدعائها. </li>\n",
    "<li>\n",
    "التعرف على أنواع مدخلات الدوال وكيفية استخدامها. </li>\n",
    "<li>التعرف على الدوال الداخلية وخواصها</li>\n",
    "<li>\n",
    "التعرف على مخرجات الدوال.</li> \n",
    "<li>تعلم الطريقة المختصرة لكتابة الدوال عن طريق استخدام lambda</li>\n",
    "    <li>\n",
    "    التعرف على الطريقة الصحيحة لكتابة تعليقات إرشادية تشرح كيفية استخدام الدوال.\n",
    "    </li>\n",
    "</ol>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b36e1ac0-b1a4-42a0-83df-ec4d2810a425",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "\n",
    "<h2 class=title>\n",
    "تعريف الدوال\n",
    "</h2>\n",
    "<div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30ba36c0-2842-4c1f-8392-c656db2a05e6",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "لكتابة دالة في بايثون نستخدم def في بداية السطر لتبليغ مفسر بايثون بأننا نرغب في تعريف دالة جديدة ثم نتبع def بإسم الدالة الذي ينتهي بقوسين اعتياديين () يوضع داخلهما مدخلات الدالة وفي نهاية السطر نكتب نقطتين فوق بعض كما في المثال التالي:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e6f6df88-9b72-4372-81bb-02113756fd56",
   "metadata": {},
   "outputs": [],
   "source": [
    "def function_name():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a79d9320-d458-4e3c-a603-646dbc0d6b15",
   "metadata": {},
   "source": [
    "<div class=arabic>لاحظ أن في الدالة السابقة كتبنا اسم الدالة ليكون function_name وبإمكانك أن تستخدم أي اسم آخر شريطة أن تنطبق عليه شروط كتابة أسماء المتغيرات التي تعرفنا عليها في الفصل الثاني. كما أننا في المثال السابق لم نقم بوضع أي مدخلات داخل قوسي الدالة لأن ذلك الأمر اختياري بحسب إحتياج الدالة للمدخلات. وأخيراً فإن كلمة   pass  والتي تعنى أن الدالة تم تعريفها فقط و لا تقوم بعمل أي شيء حتى الآن. ولكي نجعل الدالة تقوم بعمل ما فإننا نقوم بكتابة كود برمجي ليحل محل كلمة  pass كما في المثال التالي: \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d13ec31b-bca9-491d-bef3-e8a20d312f6e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def hello():\n",
    "    print(\"hello I am inside a function\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0fab05d5-c7ed-434e-8fca-90c4a9393dca",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "لاحظ أيضاًً أن الكود البرمجي داخل الدالة يكتب بعد ترك مسافة على الأقل بمقدار حرف واحد والمتعارف عليه بين مبرمجي بايثون هو ترك مسافة بمقدار أربعة أحرف. كما يجب التذكير بأن جميع أسطر الكود البرمجي داخل الدالة يجب أن تترك نفس المسافة وإلاّ سوف يعطي مفسر بايثون إشعارا بوجود خطأ.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d38d0225",
   "metadata": {},
   "source": [
    "## استدعاء الدوال"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67e77738",
   "metadata": {},
   "source": [
    "لا يتم تنفيذ الكود داخل الدالة إلاّ بعد استدعائها وذلك بكتابة اسم الدالة متبوعا بقوسين بداخلهما مدخلات الدالة إن كان هناك مدخلات للدالة أما إذا لم يكن هناك مدخلات للدالة فيكتفى بكتابة قوسين فارغين كما في المثال التالي"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "8ea51808-bee7-43ac-9338-10ba41e3c71c",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello I am inside a function\n"
     ]
    }
   ],
   "source": [
    "hello()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e74ee2f-1088-4e1f-9438-fb3e32078462",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "عند تشغيل الكود في المثال أعلاه سوف يقوم مفسر بايثون بالبحث في ذاكرة الكمبيوتر عن دالة اسمها hello ليدخل اليها وينفذ ما بداخلها من أكواد برمجية وإذا لم يجد تعريفاً لها فسوف يعطي رسالة تفيد بعدم وجود تعريف بهذا الاسم كما في المثال التالي:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c5f3b3b1",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'myinfo' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_28909/2987341299.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmyinfo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'myinfo' is not defined"
     ]
    }
   ],
   "source": [
    "myinfo()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "155fa8ae",
   "metadata": {},
   "source": [
    "لذلك يمكن كتابة تعريف الدالة في أي مكان من البرنامج شريطة أن لا يسبق استدعاءها تعريفها عند كتابة البرنامج. لاحظ أيضاً أن في الأمثلة السابقة كتبنا قوسي الدالة فارغين لأن الدالة لاتتطلب أي معلومات إضافية لتنفيذ الكود البرمجي داخلها.    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6533f929",
   "metadata": {},
   "source": [
    "## مدخلات الدوال"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3098fd33",
   "metadata": {},
   "source": [
    "لنفرض الآن أننا نريد كتابة دالة أكثر ذكاءً بحيث تقوم بالقاء التحية على أي شخص ندخل اسمه للدالة. للقيام بهذه المهمة يمكن كتابة الدالة بالطريقة التالية"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53b0a4c4-9e9d-43a0-b07f-3af84901166c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def hello(name):\n",
    "    print(\"Hello \", name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8662153-6a1e-4eff-abb6-2ebeea7190ee",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "لاحظ عند كتابتنا للدالة السابقة قمنا باعطاء اسم الشخص المراد القاء التحية عليه متغير اسميناه name ووضعناه داخل قوسي الدالة. ومن ثم استخدمنا هذا المتغير في كتابة أمر الطباعة. يسمى هذه المتغير مدخل الدالة. وعند استدعاء الدالة ما علينا القيام به هو إدخال اسم الشخص المراد القاء التحية عليه كنص كما في المثلة التالية: \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c98d9a6a-3d2a-4da0-a6cd-43f2d3b16951",
   "metadata": {},
   "outputs": [],
   "source": [
    "hello(\"Ahmad\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "286461df",
   "metadata": {},
   "outputs": [],
   "source": [
    "hello(\"Ali\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ee891a69",
   "metadata": {},
   "outputs": [],
   "source": [
    "hello(\"Sara\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79a6a83c-50f9-40ee-82f3-490a617b9335",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    " كما يمكن كتابة دالة باكثر من مدخل يفصل بينها بفاصلة داخل قوسي الدالة كما في المثال التالي:\n",
    "</div>\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "779d96b5-d4a0-4c1a-aecc-d9c6ed0ba248",
   "metadata": {},
   "outputs": [],
   "source": [
    "def addition(x,y):\n",
    "    print(\"مجموع الرقمين هو:\", x+y)\n",
    "\n",
    "addition(3,4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "013d5cbd",
   "metadata": {},
   "source": [
    "### أنواع مدخلات الدوال"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3546a9f-bf84-4403-b2d8-b95e514118ff",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "يجب الإشارة الى أن مدخلات الدالة تنقسم الى ثلاثة أقسام. القسم الأول يسمى مدخلات الزامية بحيث أنه متى ما تم كتابتها داخل قوسي الدالة عند تعريفها فإن الدالة لا يمكن استدعاءها إلاّ بعد تزويدها بهذه المدخلات كما في المثال التالي: </div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "98f73514",
   "metadata": {},
   "outputs": [],
   "source": [
    "def power(a):\n",
    "    print(a**2)\n",
    "power()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93b02597",
   "metadata": {},
   "source": [
    "تفيد رسالة الخطأ السابقة أنه تم تعريف الدالة power بمتغير الزامي a لكن هذا المتغير كان مفقوداً عند استدعاء الدالة. وعندما نزودها بهذه القيمة فإن الدالة تفنذ بشكل طبيعي كما في المثال التالي:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1a2dc9cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "power(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc72d916",
   "metadata": {},
   "source": [
    "والقسم الثاني من مدخلات الدالة يسمى مدخلات اختيارية. بحيث تعطى هذه المدخلات قيم افتراضية عند تعريف الدالة باستخدام علامة اليساوي \"=\". وعند استدعاء الدالة يمكن للمبرمج استبدال القيم الافتراضية بقيم جديدة والا قام مفسر بايثون باستخدام القيم الافتراضية التي تم كتابتها داخل قوسي الدالة وقت تعريفها كما في المثاليين التاليين:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "91da96f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def power(a=4):\n",
    "    print(a**2)\n",
    "power()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a83c2c74",
   "metadata": {},
   "outputs": [],
   "source": [
    "power(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "570123c6",
   "metadata": {},
   "source": [
    "ولكي نوضح الفرق بين هذين االنوعين من المدخلات للننظر للمثال التالي:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53847626-5c41-4b7d-9b89-c532da77deab",
   "metadata": {},
   "outputs": [],
   "source": [
    "def addition(x,y=4):\n",
    "    print(x+y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae357af1-34c7-4fe9-996d-9784a6861134",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "يعتبر المدخل x إلزامي بينما المدخل y اختياري وذلك لأننا قمنا باعطائه قيمة افتراضية هي العدد 4.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b4dedc6-308d-448f-99c5-e974386ad349",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "الآن إذا أردنا أن نستدعى الدالة السابقة بدون مدخلات فان مفسر بايثون سوف يعطينا إشعارا بوجود خطأ مفاده أن مدخلاً الزامياً واحدأ مفقود وليس مدخلين كما في المثال التالي:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b73c2570-0cae-4c97-92e4-fc3ef7edc067",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "addition()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fb69f7d-1443-4668-8b6e-4eeabbaedba4",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "لنقوم الآن بااستخدام مدخل واحد لاستدعاء الدالة كما في المثال التالي:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "89ee9b40-cbe6-43e8-82c4-538ff3bf041a",
   "metadata": {},
   "outputs": [],
   "source": [
    "addition(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4624e36f-a181-4372-b737-2a2a46fefc9a",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "المدخل الذي استخدمناه في المثال السابق هو المدخل الإلزامي والذي يمثل قيمة x أما المدخل الاختياري فقد قام مفسر بايثون باستخدام قيمته الافتراضية (4) عندما اهملنا ادخالها وقت استدعائنا للدالة. إذا رغبنا في تغيير القيمة الافتراضية للمدخل y فإننا نقوم بإدخال القيمة وقت استدعاء الدالة بعد إدخال قيمة x أولاً كما في المثال التالي:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f3350242-6e6c-4b3b-a3c3-407ec6a49f93",
   "metadata": {},
   "outputs": [],
   "source": [
    "addition(2,9)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "521c990d-c3d0-462c-83c4-bd25e7f9e9e7",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "إن ترتيب إدخال قيم المدخلات عند استدعاء الدالة مهم جدا ففي المثال السابق المدخل x أخذ القيمة 2 والمدخل y أخذ القيمة 9 وذلك بحسب الترتيب المتبع عند تعريف الدالة. يجب الإشارة الى أنه إذا تم استخدام اسم المدخل عند استداعاء الدالة فان ترتيب المدخلات يصبح غير مهم كما في المثال التالي: \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "01b145a9-45c5-4fc1-bfcd-acd0c97771ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "addition(y=8,x=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42930c50-d32b-401b-b656-5e05f51995ae",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "ففي المثال السابق تم إدخال قيمة y قبل قيمة x ولكن مفسر بايثون تعرف على قيم كل مدخل عندما زودناه بأسماء المدخلات لذلك أصبح ترتيب المدخلات غير مهم. يجب أن نشير الى أن مفسر بايثون لا يسمح بتعريف دالة تحتوي على مدخلات إلزامية ومدخلات اختيارية إلاّ بترتيب معين  وهو البدء بالمتغيرات الإلزامية أولاً ثم المدخلات الاختيارية ثانياً. وعند تعريف دالة بعكس هذا الترتيب فإن مفسر بايثون يعطي اشعارا بوجود خطأ مفاده ان مدخلاً الزاميًا أُدخل بعد مدخلٍِ اختياري كما في المثال التالي:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "93e93c3d-c070-41d8-9dd9-9984b3a7e0c2",
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "non-default argument follows default argument (4098089560.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"/tmp/ipykernel_28940/4098089560.py\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    def addition(y=4,x):\u001b[0m\n\u001b[0m                 ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m non-default argument follows default argument\n"
     ]
    }
   ],
   "source": [
    "def addition(y=4,x):\n",
    "    print(x+y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f906c5af",
   "metadata": {},
   "source": [
    "القسم الثالث من مدخلات الدالة يسمى المدخلات المرنة. ما ذا لو أننا أردنا كتابة دالة بحيث نعطي المستخدم حريته في اختيار عدد المدخلات التي يود معالجتها كأن تكون لدينا دالة تقوم بحساب حاصل ضرب القيم التي ندخلها لها بحيث يمكن أن يكون عدد القيم المدخلة 2 أو 3 أو 4 أو أي عدد من القيم الذي يختاره المستخدم فماذا عسانا أن نعمل. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc31abff",
   "metadata": {},
   "source": [
    "لم يغفل مبرمجوا لغة بايثون عن هذه الخاصية ووضعوا تركيباً يمكّن مفسر بايثون من  تعريف دالة ٍ مرنة المدخلات الإلزامية باستخدام علامة النجمة قبل اسم المدخل كما هو موضح في المثال التالي:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6b542dad",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def mult(*num):\n",
    "    product=1\n",
    "    for n in num:\n",
    "        product=product*n  \n",
    "    return product\n",
    "mult(2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "68b6f2e7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mult(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "a98855eb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mult(2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "c43031ff",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mult(1,2,3,4,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f779a57a",
   "metadata": {},
   "source": [
    "يجب ملاحظة ان المدخل الألزامي المرن يتم التعامل معه على أنه قائمة أو مصفوفة كما هو موضح في المثال السابق."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e0e4754",
   "metadata": {},
   "source": [
    "كما يمكن تعريف دالة بمدخلات اختيارية مرنة من خلال  وضع علامتي نجمة  أمام المتغير الذي سوف يمثل عدد المتغيرات الاختيارية كما في المثال التالي:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "8003e1f9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def total_fruits(**fruits):\n",
    "    total = 0\n",
    "    for amount in fruits.values():\n",
    "        total += amount\n",
    "    return total\n",
    "total_fruits(banana=5, mango=7, apple=8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "c2707f99",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total_fruits(banana=5, mango=7, apple=8, oranges=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "21e46926",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total_fruits(banana=5, mango=7)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d21480a8",
   "metadata": {},
   "source": [
    "يجب ملاحظة أن المدخلات الاختيارية المرنة يتم التعامل معها على أنها قاموس كما هو موضح في المثال السابق."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9419803a",
   "metadata": {},
   "source": [
    "## مخرجات الدوال"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c495fc26-e7e2-4f38-850a-76f73dbd45bf",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    " لنفرض الآن أننا لا نريد طباعة ما تقوم به الدالة على الشاشة ولكن نريد فقط إرجاع ما نتج من عمليات داخل الدالة ليكون قيمة لمتغير بحيث نستطيع ادخال هذه القيمة في عمليات أُخرى. لكي نقوم بهده المهمة لابد لنا من استخدام العبارة return لإخبار مفسر بايثون بأن الدالة تود إرجاع محصلة الكود البرمجي داخلها الى متغير آخر كما في المثال التالي:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd52dafd-dc6d-434f-bb18-30409d238593",
   "metadata": {},
   "outputs": [],
   "source": [
    "def addition(x,y):\n",
    "    return x+y\n",
    "\n",
    "sum=addition(3,7)\n",
    "print(sum**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28195bab-1248-483f-8702-e5e376318419",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "في المثال السابق تم اسناد ناتج الدالة الى المتغير sum ومن ثم قمنا بطباعة قيمة المتغير بعد تربيعها. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40386c2f-65bb-44f6-b4e3-8844dc6833a8",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "في حقيقة الأمر إن الدالة دائماً تقوم بإرجاع محصلتها حتى لو لم نكتب العبارة return. فإذا لم نستخدم العبارة return فإن الدالة تقوم بإرجاع قيمة افتراضية هي None وتعني أنه لم يتم إرجاع أي شيئ. كما في المثال التالي:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de8707fb-88b5-49c8-8053-89d28bddcef6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def addition(x,y):\n",
    "    z=x+y\n",
    "\n",
    "sum=addition(5,9)\n",
    "print(sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fef7c53c-a808-4cf2-a77f-960bb523b662",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "    لاحظ أن الدالة السابقة قامت بجمع المدخلين وإسناد النتيجة الى المتغير z. وبما أننا لم نستخدم الأمر return لإرجاع قيمة المتغير z فان الدالة قامت بإرجاع القيمة الافتراضية None. هذي النقطة تقودنا الى ما يسمى بمحال المتغيرات داخل الدوال.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c85f2630",
   "metadata": {},
   "source": [
    "## مجال المتغيرات داخل الدوال"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8536e9eb",
   "metadata": {},
   "source": [
    "المتغير z في الدالة السابقة تم مسحه من الذاكرة بمجرد أن تم الإنتهاء من تنفيذ الدالة لذلك تسمى هذه المتغيرات بالمتغيرات المحلية أما المتغيرات التى تقع خارج الدوال فتسمى متغيرات عالمية (global variables) بحيث تحتفظ بقيمتها في أي مكان من البرنامج حتى لو كانت في داخل الدوال كما في المثال التالي"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "4d0376dc-710a-4beb-a29b-977d6c760bf6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "x=5\n",
    "def addition():\n",
    "    print(x)\n",
    "\n",
    "addition()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f39af9b-e1b0-4858-9105-b91ed9f9cbbb",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "لكن هناك أمر مهم يجب أن تعرفه وهو أنه لا يمكننا تغيير قيم المتغيرات العالمية داخل الدوال إلاّ بعد استخدام كلمة global قبل اسم المتغير المراد تغيير قيمته داخل الدالة كما في المثال التالي:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c2b3e09-780b-4e0b-83b5-631194249620",
   "metadata": {},
   "outputs": [],
   "source": [
    "x=5\n",
    "def change_x():\n",
    "    global x\n",
    "    x=10\n",
    "\n",
    "change_x()\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ccf015b-7e0b-4ffd-821b-6b06a901892c",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "لاحظ أن كلمة global في المثال السابق أبلغت مفسر بايثون بأن هذا المتغير عالمي ويجب الإحتفاظ بقيمته حتى بعد الإنتهاء من تنفيذ الدالة. أما إذا لم نستخدم كلمة global فان مفسر بايثون سوف يفترض أن x متغير محلى غير المتغير x الذي يقع خارج الدالة وسوف يمحو قيمته من الذاكرة بعد الإنتهاء من تنفيذ الدالة ولا يحدث أي تغيير للمتغير الواقع خارج الدالة كما في المثال التالي:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "35043e27-b2ac-4538-9308-947ed1d46802",
   "metadata": {},
   "outputs": [],
   "source": [
    "x=5\n",
    "def change_x():\n",
    "    x=10\n",
    "\n",
    "change_x()\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ec2790d",
   "metadata": {},
   "source": [
    "## الدوال الداخلية"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eab381cc",
   "metadata": {},
   "source": [
    "كما يجب الإشارة الى أنه بالإمكان إستدعاء دالة من داخل دالة كما في المثال التالي:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a66b085e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "call me from inside\n"
     ]
    }
   ],
   "source": [
    "def inner():\n",
    "    print(\"call me from inside\")\n",
    "    \n",
    "def outer():\n",
    "    inner()\n",
    "\n",
    "outer()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16e3e34b",
   "metadata": {},
   "source": [
    "وكذلك يمكن تعريف دالة داخل  دالة  ولكن يجب استدعاء الداخلية من داخل الدالة الأم وإلاّ سوف يتم مسح تعريف الدالة الداخلية من ذاكرة الكمبيوتر بعد الإنتهاء من تنفيذ كود الدالة الأم كما في المثالين التاليين:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d53a084e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am inside inner\n"
     ]
    }
   ],
   "source": [
    "def outer():\n",
    "    def inner():\n",
    "        print(\"I am inside inner\")\n",
    "    inner()\n",
    "outer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0d5a0eaf",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'inner2' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_28940/2232286928.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      3\u001b[0m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"I am inner2\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mouter2\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0minner2\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'inner2' is not defined"
     ]
    }
   ],
   "source": [
    "def outer2():\n",
    "    def inner2():\n",
    "        print(\"I am inner2\")\n",
    "outer2()\n",
    "inner2()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89b3284d",
   "metadata": {},
   "source": [
    "في  المثال الأول تم تعريف الدالة inner داخل الدالة outer وتم استدعاء الدالة inner من داخل الدالة الأم outer فتم تنفيذ الكود البرمجي الذي يقع داخل الدالة الداخلية inner. في المثال الثاني تم تعريف الدالة الداخلية inner2 داخل الدالة الخارجية outer2 لكن عملية الإستدعاء تمت من خارج الدالة الأم لذلك عندما انتهى مفسر بايثون من تنفيذ الدالة الأم التي بداخلها تعريف الدالة الداخلية inner2 تخلص مفسر بايثون من جميع المتغيرات المحلية ومن ضمنها تعريف الدالة inner2. لذلك عندما قمنا باستدعاء الدالة الداخلية inner لم يجد مفسر بايثون أي ا ثر للدالة الداخلية وأعطانا رسالة تفيد بعدم وجود المتغير inner2. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e3e0eda",
   "metadata": {},
   "source": [
    "يمكن تجاوز هذه المشكلة  بحيث يمكننا استدعاء الدالة التي تم تعريفها من داخل دالة اخرى بتكون متغير عالمي داخل الدالة الأم ومن ثم نقوم باسناد الدالة الداخلية لهذا ا لمتغير بحيث يمكننا استدعائها من خارج الدالة الأم كما في المثال التالي:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "807ea9de",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am inside inner3\n"
     ]
    }
   ],
   "source": [
    "def outer3():\n",
    "    global inner3\n",
    "    def inner3():\n",
    "        print(\"I am inside inner3\")\n",
    "outer3()\n",
    "inner3()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d658718",
   "metadata": {},
   "source": [
    "كما يجب الإشارة الى أنه بالإمكان ارجاع الدالة الداخلية كناتج للدالة الخارجية باستخدام العبارة return كما هو موضح في المثال التالي:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "7c6da8f3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am inside inner3\n"
     ]
    }
   ],
   "source": [
    "def outer3():\n",
    "    global inner3\n",
    "    def inner3():\n",
    "        print(\"I am inside inner3\")\n",
    "    return inner3\n",
    "inner3=outer3()\n",
    "inner3()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3abe3fe6",
   "metadata": {},
   "source": [
    "ويمكن كتابة المثال السابق بطريقة اخرى كما في المثال التالي:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "dd5086af",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am inside inner3\n"
     ]
    }
   ],
   "source": [
    "def outer3():\n",
    "    global inner3\n",
    "    def inner3():\n",
    "        print(\"I am inside inner3\")\n",
    "    return inner3\n",
    "outer3()()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20baf3d7",
   "metadata": {},
   "source": [
    "## الطريقة المختصرة لكتابة الدوال"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ed96d73",
   "metadata": {},
   "source": [
    "بالإضافة الى الطريقة التلقيدية التي تناولنهاها بشيئ من التفصيل هناك طريقة مختصرة لكتابة الدوال باستخدام العبارة lambda كما هو موضح في المثال التالي: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "d59a4af3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f=lambda x: x**2\n",
    "f(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59591312",
   "metadata": {},
   "source": [
    "فالتركيب اللغوي لكتابة الدوال المختصرة يبدأ بكتابة العبارة lambda متبوعاً بالمدخلات التي سوف تدخل في العمليات التي سوف تجريها الدالة.  تنتهي المدخلات بنقطتين فوق بعض يكتب بعدها العمليات التي يود المبرمج إجراءها داخل الدالة. يمكن هذا التركيب من كتابة الدالة بدون اسم فيطلق عليها احياناً الدالة الغامضة anonymous function ويمكن ايضاً ان يسند هذا التركيب لمتغير يشير الى هذه الدالة كما فعلنا في المثال السابق باسناد الدالة التربيعية الى المتغير f. ويتم تنفيذ الدالة المختصرة بنفس الطريقة التقليدية التي تعلمناها سابقاً بأن توضع المدخلات بين قوسين بعد اسم المتغير الذي يشير الى الدالة المختصرة.  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee8c847b",
   "metadata": {},
   "source": [
    "ويمكن التأكد من أن المتغير f أصبح يشير الى دالة باستخدام الدالة type كما هو موضح في المثال التالي:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "80f447cf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "function"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5bd7f17d",
   "metadata": {},
   "source": [
    "لاستخدام أكثر من مدخل في الدالة المختصرة يفصل بين المدخلات بفاصلة كما تعلمنا سابقاً كما هو موضح في المثال التالي:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "823597ed",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f=lambda x,y:x**2+y**2\n",
    "f(4,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "229d86d0",
   "metadata": {},
   "source": [
    "لاحظ أن ترتيب المدخلات وقت تنفيذ الدالة مهم كما تعلمنا سابقاً مع الدوال التقليدية."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3959c8c0-2f5d-478c-b2a9-0933c3f6d5de",
   "metadata": {},
   "source": [
    "<div class=arabic><h2 class=title>التعليقات الارشادية للدوال</h2></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d4dc5df-dd75-48b8-b35d-36e5191636b0",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "ينص دليل بايثون الارشادي رقم PEP 8 الخاص بتوحيد طريقة تنسيق وكتابة الأكواد البرمجية وجعلها سهلة القراءة لكافة المبرمجين على أنه يجب كتابة ملخص على شكل تعليق أو ملاحظة في السطر الذي يتلو اسم الدالة بحيث يشير فيه المبرمج على الوظيفة التي تقوم بها الدالة كما في المثال التالي:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "4d73c0b1-0cf0-4f61-95b9-2a2e15230aa6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_two_numbers(x,y):\n",
    "    '''تقوم هذه الدالة بحساب مجموع الرقمين المدخلين وارجاع حاصل جمعها'''\n",
    "    return x+y"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f14f222e-60d1-460b-8d10-72a84307c753",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "يمكن التعرف على التعليق الذي كتبه المبرمج عن دالته التي كتبها باستخدام الدالة ثنائية الشرطة السفلية __doc__ بعد اسم الدالة التي نود معرفة معلومات حولها كما هو موضح في المثال التالي:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "fc8489a5-1eb7-4f38-826b-4e424e4548fe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "تقوم هذه الدالة بحساب مجموع الرقمين المدخلين وارجاع حاصل جمعها\n"
     ]
    }
   ],
   "source": [
    "print(add_two_numbers.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a2e55c8-5289-469c-a2af-d32970eabad2",
   "metadata": {},
   "source": [
    "<div class=arabic><h2 class=title>تمارين استكشافية</h2></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e460d8e-23e0-4c49-8746-07eb0800b1a9",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "    1.\tتعرف على التعليمات الارشادية للدالة ()len التي تعلمناها سابقاً؟\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e49915e-c690-422c-9be3-d750a8367be9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "245512e6-d63b-4907-9a9d-99a1ab3a1a6a",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "    1.\tتعرف على التعليمات الارشادية للدالة ()type ؟\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f96f5943-5711-4e70-beea-725e0e0a90db",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "81a60cf3-db1d-43d1-94c1-72117621c669",
   "metadata": {},
   "source": [
    "<div class=arabic>\n",
    "    1.\tتعرف على التعليمات الارشادية للدالة ()print ؟\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c26c92ae-9b03-482b-b7ce-a9b6aafb8d1c",
   "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}