{ "cells": [ { "cell_type": "raw", "metadata": { "vscode": { "languageId": "raw" } }, "source": [ "---\n", "title: \"البرمجة بالكائنات\"\n", "og:title: oop_intro\n", "toc: true\n", "format:\n", " html: default\n", "---" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[تحميل الدفتر](https://raw.githubusercontent.com/HassanAlgoz/python/main/book/chapters/ch9-oop/lesson_9.ipynb)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "![الكائن](assets/objects.png){width=33%}\n", "\n", "رأينا فيما تقدَّم طريقةً **لتبعيض مسارات البرنامج** لأجزاء تعمل على معطيَات محددة (الدالة / الإجراء)، بحيث يُمكن استدعاؤها بمعطيات مختلفة، ومرات متعددة. وكل جزء منها فيه سير للأوامر من بدايته حتى أحد النهايات بجملة الرجوع (`return`).\n", "\n", "والآن نتعرَّف على طريقة **لتبعيض البرنامج إلى برامج جزئية**؛ لها مساراتها وأيضًا متغيرتها الخاصَّة. وتسمى هذه **البرمجة الكائنية** (Object-oriented Programming - OOP) حيث يحتفظ كل كائن بأمرين:\n", "\n", "1. **الحال** (State) وتمثِّلُها المتغيرات، والإجراءات التي تقرأ من تلك المتغيرات.\n", "2. **الانتقال** (Transition) وتمثِّلُها الإجراءات التي تكتب في تلك المتغيرات (أو تكتب في منافذ المخرجات)\n", "\n", "وبالمثال يتضح المقال.\n", "\n", "**القائمة** ([`list`](https://docs.python.org/3/library/stdtypes.html#list)) يتم إنشاؤها بالقوسين المربعين `[]`، وهذا من اختصارات بايثون. والأصل أن الكائن يتمُّ إنشاؤه بذكر نوعه مع القوسين `()` ليتم استدعاء الإجراء المُنشئ للكائن، على هذا النحو:\n" ], "id": "4778043a" }, { "cell_type": "code", "metadata": {}, "source": [ "xs1 = []\n", "xs2 = list()\n", "print(xs1 == xs2)\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "فأما حال القائمة:\n", "\n", "- قيَم العناصر التي تحتويها\n", "- موضِع كل عنصر فيها بالترتيب\n", "- عدد العناصر\n", "\n", "ويُمكِنُ **قراءة** (Read) الحال بالإجراءات التالية:\n", "\n", "- الإشارة للموضع: `print(xs[0])`\n", "- العد: `len(xs)`\n", "- البحث: `.index(10)`\n", "- العضوية: `10 in xs`\n", "- الكر: `for x in xs`\n", "- المقارنة: `xs == ys`\n", "\n", "وأما الانتقال من حالٍ إلى حال، فيتم بأحد إجراءات **الكتابة** (Write):\n", "\n", "- الإضافة: `xs.append(50)`\n", "- الحذف: ` xs.remove(50)`\n", "- التعديل: `xs[0] = 30`\n", "\n", "وكل ما سبق عمليَّات تمثَّل بإجراءات، لكنَّ قد يحلّ محل اسم الإجراء عامل يدلُّ عليه:\n", "\n", "- فالعمليات المصرَّح فيها باسم الإجراء فنحو: `.append()` و `.remove()`. وإذا أُسنِدَ الإجراء للكائن فهو مما يختصُّ به لا بغيره؛ فالمفعول به هو هذا الكائن، فيكون مُعطىً مُقدَّر لا يحتاج لتمريره بين القوسين.\n", "- ولعلك تلاحظ عمليات أخرى لكنَّها تستعمل إجراءات لا تختص بهذا الكائن تحديدًا، نحو: `print()` و `len()`.\n", "- ومن الإجراءات ما **يعوَّض مكان العامل**، نحو: `xs[0]` فهو إجراء قراءة اسمه: (`__getitem__`) لكن بايثون تخصُّه بهذه الكتابة للاختصار. ومثله أيضًا: `xs == ys` فهو يستدعي إجراء المقارنة (`__eq__`) وكذلك البحث (`__contains__`).\n", "وأما الكر فيتطلب وجود إجراء (`__iter__`) يُرجِع كائنًا له الإجراء (`__next__`).\n", "\n", "وهذه الأسماء تهمُّنا عند تعريف أنواع بأنفسنا.\n", "\n", "## تعريف النوع\n", "\n", "تأمل المثال التالي:\n" ] }, { "cell_type": "code", "metadata": {}, "source": [ "class Counter:\n", " def __init__(self, count):\n", " self.count = count\n", " \n", " def increment(self, by=1):\n", " self.count += by\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "![نوع العداد](assets/object_counter.png){width=25%}\n", "\n", "- **الصنف** (Class): `Counter`\n", "- **الخصائص** (Properties): هي كل ما تم تعيينه وإسنادُه إلى `self` وهي هنا: `count` فقط\n", "- **الطرائق** (Methods): وهي كل إجراء تم تعريفُه في داخل تعريف النوع، وهي هنا: `increment` فقط\n", "\n", "أما إجراء [`__init__`](https://docs.python.org/3/reference/datamodel.html#object.__init__) (بشرطتين قبل وشرطتين بعد `__`) يرمز للكلمة (Initialization) وتعنى **الإنشاء**؛ ويتم استدعاؤُها فوْر ذِكر اسم النوع كدالة لإنشائه في نحو: `Counter(0)`.\n", "\n", "تتقدَّم `self` (**نفس**) كمعطى في الابتداء في جميع الأفعال؛ والإسنادُ إليها إسنادٌ لكائن مُضمَر أنشئ من هذا النوع.\n", "\n", "## إنشاء الكائنات\n", "\n", "تتم كتابة اسم الصنف، ثم القوسان (عامل الاستدعاء) وبينهما المعطيات لطريقة الإنشاء `__init__` على النحو التالي:\n" ] }, { "cell_type": "code", "metadata": {}, "source": [ "c1 = Counter(10)\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "وللوصول إلى خاصية أو طريقة ما فإننا نتسعمل عامل الوصول، النقطة (`.`) على النحو التالي:\n" ] }, { "cell_type": "code", "metadata": {}, "source": [ "print(c1.count)\n", "c1.increment(2)\n", "c1.increment(3)\n", "print(c1.count)\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "وهذا معيَّن آخر من نفس الصنف:\n" ] }, { "cell_type": "code", "metadata": {}, "source": [ "c2 = Counter(0)\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "وكل واحد منهما له حال خاصَّة به:\n" ] }, { "cell_type": "code", "metadata": {}, "source": [ "print(c1.count)\n", "print(c2.count)\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "## عوامل الحاويات\n", "\n", "وكي يتضح مفهوم الأصناف، فإننا سنمثل **المجموعة الرياضية** (`Set`) بأنفسنا، وإن كانت جودودة في بايثون أصلاً.\n", "\n", "تسمي بايثون الحروف والعلامات المستعملة مع أنواع الجموع: [**عوامل الحاوية**](https://docs.python.org/3/reference/datamodel.html#emulating-container-types) (Container Operators).\n", "\n", "ونمثل بتعريف صنف **المجموعة الرياضية**، حيث تقبل:\n", "\n", "- العد: `len(s)` يُسمَّى فعله: `__len__`\n", "- العضويَّة: `x in s` يُسمَّى فعله: `__contains__`\n", "- الكر: `for x in s` يُسمَّى فعله: `__iter__`\n", "- الحذف: `.remove()`\n", "\n", "ومن سماتها أن العنصر فيها لا يتكرر.\n", "\n", "ومن طرائقها: منطق المجموعة الرياضية.\n", "\n", "## منطق المجموعة الرياضية\n", "\n", "المجموعة في الرياضيات لها بعض المفاهيم المتعلقة بها وهي:\n", "\n", "- **التقاطع والاتحاد والفرق، والفرق التماثلي**\n", "- وكذلك **تحقق**: (**الجزئية والشمول والانفاصل**).\n", "\n", "وتمثلها بايثون باستعمال القوسين المعقوفين (`{}`) على هذا النحو:\n" ] }, { "cell_type": "code", "metadata": {}, "source": [ "set1 = {1, 2, 3, 4, 5}\n", "set2 = {4, 5, 6, 7, 8}\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "وفيما يلي نشرح هذه العمليات، ثم ننتقل إلى كيفية تمثيل ذلك في بايثون.\n", "\n", "## العمليات على المجموعات\n", "\n", "### الاتحاد\n", "\n", "![اتحاد مجموعتين](assets/Venn0111.png)\n" ], "id": "1d8c902f" }, { "cell_type": "code", "metadata": {}, "source": [ "set1.union(set2)\n" ], "execution_count": null, "outputs": [], "id": "b3e8cb4d" }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "### التقاطع\n", "\n", "![تقاطع مجموعتين](assets/Venn0001.png)\n" ], "id": "8a428b07" }, { "cell_type": "code", "metadata": {}, "source": [ "set1.intersection(set2)\n" ], "execution_count": null, "outputs": [], "id": "b9d8c019" }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "### الفرق\n", "\n", "![الفرق](assets/Venn0010.png)\n" ], "id": "5941b2e6" }, { "cell_type": "code", "metadata": {}, "source": [ "set1.difference(set2)\n" ], "execution_count": null, "outputs": [], "id": "4fce7a90" }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n" ], "id": "800317b8" }, { "cell_type": "code", "metadata": {}, "source": [ "set2.difference(set1)\n" ], "execution_count": null, "outputs": [], "id": "e20d7f6a" }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "### الفرق التماثلي\n", "\n", "![الفرق التماثلي](assets/Venn0110.png)\n" ], "id": "aa209411" }, { "cell_type": "code", "metadata": {}, "source": [ "set1.symmetric_difference(set2)\n" ], "execution_count": null, "outputs": [], "id": "9eaaa989" }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "## العلاقات بين المجموعات\n", "\n", "### الجزئية والشمول\n", "\n", "![الجزئية والشمول](assets/Venn_A_subset_B.png)\n" ], "id": "fb40e633" }, { "cell_type": "code", "metadata": {}, "source": [ "A = {1, 2, 3}\n", "B = {1, 2, 3, 4, 5, 6}\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "وهذا مثال لاستعمالها كما في الجدول:\n" ] }, { "cell_type": "code", "metadata": {}, "source": [ "print(A.issubset(B))\n", "print(B.issuperset(A))\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "### الانفصال\n", "\n", "وأما الانفصال، فهو عدم وجود أدنى تقاطع بين المجموعتين:\n" ] }, { "cell_type": "code", "metadata": {}, "source": [ "C = {'Apple', 'Banana'}\n", "print(C.isdisjoint(A))\n", "print(C.isdisjoint(B))\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "## تعريف المجموعة الرياضية\n", "\n", "ونعرف **المجموعة الرياضيَّة** (`Set`) بأنفسنا لغرض تعليمي وإن كانت نوعًا أصليًّا في بايثون اسمه (`set`).\n", "ولاحظ أن التمثيل الداخلي (Internal Representation) الذي سنعتمد عليه هو: القائمة (`list`) الممثلة بالمتغيِّر: `self.elements`.\n" ] }, { "cell_type": "code", "metadata": {}, "source": [ "class Set:\n", " # طريقة الإنشاء\n", " def __init__(self, elements):\n", " self.elements = elements\n", "\n", " # طريقة التمثيل\n", " def __repr__(self):\n", " return f\"Set({self.elements})\"\n", " \n", " # طريقة العد تمررها كما هي\n", " def __len__(self):\n", " return len(self.elements)\n", " \n", " # طريقة العضويَّة تمررها كما هي\n", " def __contains__(self, x):\n", " return x in self.elements\n", " \n", " # طريقة التكرار تمررها كما هي\n", " def __iter__(self):\n", " return iter(self.elements)\n", " \n", " # طريقة الإضافة تتحقق أولاً من عدم وجود العنصر\n", " def add(self, x):\n", " if x not in self.elements:\n", " self.elements.append(x)\n", " \n", " # طريقة الحذف تتحقق أولاً من وجود العنصر\n", " def remove(self, x):\n", " if x in self.elements:\n", " self.elements.remove(x)\n", " \n", " # طريفة الاتحاد\n", " def union(self, other):\n", " result = []\n", " for x in self.elements + other.elements:\n", " if x not in result:\n", " result.append(x)\n", " return Set(result)\n", " \n", " # طريقة التقاطع\n", " def intersection(self, other):\n", " result = []\n", " for x in self.elements:\n", " if x in other.elements:\n", " result.append(x)\n", " return Set(result)\n", " \n", " # طريقة الفرق\n", " def difference(self, other):\n", " result = []\n", " for x in self.elements:\n", " if x not in other.elements:\n", " result.append(x)\n", " return Set(result)\n", " \n", " # طريقة الفرق التماثلي\n", " def symmetric_difference(self, other):\n", " d1 = self.difference(other)\n", " d2 = other.difference(self)\n", " return d1.union(d2)\n", " \n", " # طريقة الانفصال\n", " def isdisjoint(self, other):\n", " return len(self.intersection(other)) == 0\n", " \n", " # طريقة الجزئية\n", " def issubset(self, other):\n", " for x in self.elements:\n", " if x not in other.elements:\n", " return False\n", " return True\n", " \n", " # طريقة الشمول\n", " def issuperset(self, other):\n", " return other.issubset(self)\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "ولاحظ في المثال السابق عدة أمور:\n", "\n", "\n", "الطريقة (`__repr__`) تعني **التمثيل** (Representation)، وهي تظهر حين نعرض الكائن مثلاً بأمر الطباعة `print()`.\n", "\n", "أن بعض الطرائق تغير التمثيل الداخلي (`elements`) مباشرةً، مثل: `add` و `remove`.\n", "\n", "وبعض الطرائق يُنشئ نُسخة جديدة منه، ويجري العمليَّة عليه، ثم يُنشئ كائن مجموعة (`Set`) ويمرر إليه هذا التمثيل ويرجع به: `return Set(result)`.\n", "**والفائدة من هذه الحركة**: هي إمكانيَّة استعمال هذه الطرائق ضمن طرائق أخرى.\n", "كما ترى في `.symmetric_difference()` و `.isdisjoint()`.\n", "فلو لم نقم بهذه الحركة، لم يمكن ذلك.\n", "\n", "ثم الإنشاء والاستعمال على النحو التالي:\n" ] }, { "cell_type": "code", "metadata": {}, "source": [ "s1 = Set([1, 2, 3])\n", "s2 = Set([3, 4, 5])\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n" ] }, { "cell_type": "code", "metadata": {}, "source": [ "print(s1.union(s2))\n", "print(s1.intersection(s2))\n", "print(s1.difference(s2))\n", "print(s2.difference(s1))\n", "print(s1.symmetric_difference(s2))\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n" ] }, { "cell_type": "code", "metadata": {}, "source": [ "print(Set([1, 2]).isdisjoint(Set([3, 4])))\n", "print(Set([1, 2]).issubset(Set([1, 2, 3])))\n", "print(Set([1, 2, 3]).issuperset(Set([1, 2])))\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "## تحديد عمل العوامل\n", "\n", "تأمل التالي وتوقَّع النتيجة وعلل إجابتك. ما هي نتيجة:\n", "\n", "القطعة الأولى:\n", "\n", "```python\n", "[1, 2, 3] + [4, 5, 6]\n", "```\n", "\n", "القطعة الثانية:\n", "\n", "```python\n", "[1, 2, 3] * [4, 5, 6]\n", "```\n", "\n", "القطعة الثالثة:\n", "\n", "```python\n", "[1, 2, 3] * 5\n", "```\n", "\n", "القطعة الرابعة:\n", "\n", "```python\n", "[1, 2, 3] - 3\n", "```\n", "\n", "\n", "## عوامل الأرقام\n", "\n", "كل الذي سبق، قد تم تعريفه في بايثون لهذه الأنواع التي تراها بالتحديد عن طريق إجراءات مخصصة. وإليك هذا الجدول للعوامل المخصصة:\n", "\n", "| مثال | الإجراء |\n", "|----------|----------|\n", "| `self + other` | `__add__` |\n", "| `self - other` | `__sub__` |\n", "| `self * other` | `__mul__` |\n", "| `self / other` | `__truediv__` |\n", "| `self // other` | `__floordiv__` |\n", "| `self % other` | `__mod__` |\n", "| `self ** other` | `__pow__` |\n", "\n", "(وانظر [مرجع بايثون لمحاكاة العمليات الرقمية](https://docs.python.org/3/reference/datamodel.html#emulating-numeric-types)).\n", "\n", "فنستطيع تعريف نوع المتجَّه (Vector2D) على النحو التالي.\n" ] }, { "cell_type": "code", "metadata": {}, "source": [ "class Vector2D:\n", " def __init__(self, x, y):\n", " self.x = x\n", " self.y = y\n", " \n", " def __repr__(self):\n", " return f\"<{self.x}, {self.y}>\"\n", " \n", " def __add__(self, other):\n", " return Vector2D(self.x + other.x, self.y + other.y)\n", " \n", " def __sub__(self, other):\n", " return Vector2D(self.x - other.x, self.y - other.y)\n", " \n", " def __mul__(self, other):\n", " return Vector2D(self.x * other.x, self.y * other.y)\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "وفي الجمع والطرح والضرب، يكون العائد متجهًا جديدًا هو حاصل العملية على أفراد العناصر المتقابلة بين المتجهين `self` و `other`. حيث يمثل الأوَّل (`self`) المتجَّه في الطرف الأيسر من العامل، والثاني (`other`) في الطرف الأيمن.\n", "\n", "والآن يمكننا إنشاء متجهين ووضع العوامل بينهما:\n" ] }, { "cell_type": "code", "metadata": {}, "source": [ "v1 = Vector2D(1, 2)\n", "v2 = Vector2D(3, 4)\n", "\n", "v1 + v2\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n" ] }, { "cell_type": "code", "metadata": {}, "source": [ "v1 - v2\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n" ] }, { "cell_type": "code", "metadata": {}, "source": [ "v1 * v2\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "ماذا لو أردنا إضافة عمليات بين المتجه والعدد، نحو: `v1 + 3`? يتطلب ذلك إضافة شرط لفحص النوع، وهو `isinstance` كالتالي:\n" ] }, { "cell_type": "code", "metadata": {}, "source": [ "class Vector2D:\n", " def __init__(self, x, y):\n", " self.x = x\n", " self.y = y\n", " \n", " def __repr__(self):\n", " return f\"Vector({self.x}, {self.y})\"\n", " \n", " def __add__(self, other):\n", " if isinstance(other, Vector2D):\n", " return Vector2D(self.x + other.x, self.y + other.y)\n", " else:\n", " return Vector2D(self.x + other, self.y + other)\n", " \n", " def __sub__(self, other):\n", " if isinstance(other, Vector2D):\n", " return Vector2D(self.x - other.x, self.y - other.y)\n", " else:\n", " return Vector2D(self.x - other, self.y - other)\n", " \n", " def __mul__(self, other):\n", " if isinstance(other, Vector2D):\n", " return Vector2D(self.x * other.x, self.y * other.y)\n", " else:\n", " return Vector2D(self.x * other, self.y * other)\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "وهكذا يصبح التفاعل بين المتجَّه والعدد، وهما نوعان مختلفان (`int` و `Vector`):\n" ] }, { "cell_type": "code", "metadata": {}, "source": [ "v1 = Vector2D(1, 2)\n", "v1 + 3\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "لكن لاحظ أنك لو وضعت العدد أولاً فسيظهر خطأ:\n" ] }, { "cell_type": "code", "metadata": {}, "source": [ "#|error: true\n", "3 + v1\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "هذا لأن عملية الجمع الآن لا تنظر في نوع العدد (`int`) ولا تجد فيه قبولاً للمتجه (فقد عرفناه للتو). ولحل هذه المشكلة توفر بايثون لكل فعل مخصص مقابل يبدأ بحرف `r` على النحو التالي:\n", "\n", "| العامل | الإجراء |\n", "|----------|----------|\n", "| `other + self` | `__radd__` |\n", "| `other - self` | `__rsub__` |\n", "| `other * self` | `__rmul__` |\n", "\n", "نعدل الإجراء بحيث نضيف إليه المقابل:\n" ] }, { "cell_type": "code", "metadata": {}, "source": [ "class Vector2D:\n", " def __init__(self, x, y):\n", " self.x = x\n", " self.y = y\n", " \n", " def __repr__(self):\n", " return f\"Vector({self.x}, {self.y})\"\n", " \n", " def __add__(self, other):\n", " if isinstance(other, Vector2D):\n", " return Vector2D(self.x + other.x, self.y + other.y)\n", " else:\n", " return Vector2D(self.x + other, self.y + other)\n", "\n", " def __radd__(self, other):\n", " return self + other\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "والآن كلاهما يعمل بشكل صحيح:\n" ] }, { "cell_type": "code", "metadata": {}, "source": [ "v1 = Vector2D(1, 2)\n", "3 + v1\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n" ] }, { "cell_type": "code", "metadata": {}, "source": [ "v1 + 3\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "## التخصيص بالوراثة\n", "\n", "يُمكن جعل علاقة بين نوع ونوع.\n", "ومن ذلك **الوراثة** (Inheritance) وهي عمليَّة **تخصيص** (Sub-classing) بحيث يستمد النوع خصائصه وطرائقه من النوع الأعم.\n", "\n", "ومثاله في بايثون أنواع [الرقم](https://docs.python.org/3/reference/datamodel.html#numbers-number):\n" ], "id": "b65a9296" }, { "cell_type": "markdown", "metadata": {}, "source": [ "```{mermaid}\n", "flowchart BT\n", " Number[رقم
Number]\n", " Integral[كامل
Integral]\n", " Integral --> Number\n", " Real[حقيقي
Real]\n", " Real --> Number\n", " float[عشري
float]\n", " float --> Real\n", " Complex[مركب
Complex]\n", " Complex --> Number\n", " int[صحيح
int]\n", " int --> Integral\n", " bool[منطقي
bool]\n", " bool --> Integral\n", "```\n", "\n", "ونمثل بمثال فتقول المربع نوع خاص من المستطيلات. وكذلك تقول: المستطيل نوع خاص من الأشكال. وبالتالي فإن علاقة المربَّع بالشكل هي علاقة تخصيص عام.\n", "على نحو هذا المثال:\n", "\n", "- **الشكل**: ما كان له محيط\n", "- و**المستطيل** (Rectangle) شكلٌ (إذًا له محيط) و فوق ذلك فإنه له: طولًا وعرضًا ومساحة\n", "- و**والمثلث** شكلٌ (إذًا له محيط) و فوق ذلك فإنه له: ثلاثةَ أضلاعٍ ومساحة\n", "- أما **المربع** فهو مستطيل (إذًا له محيط لأن المستطيل شكل، وله طول وعرض ومساحة): لكن عرضه وطوله متساويان\n", "\n", "وهذه شجرة التوارث للأنواع المذكورة:\n", "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "```{mermaid}\n", "flowchart BT\n", " Shape\n", " Rectangle -- \"is a\" --> Shape\n", " Square -- \"is a\" --> Rectangle\n", " Triangle -- \"is a\" --> Shape\n", "```\n", "\n", "وهذا تعريف صنف الشكل:\n" ] }, { "cell_type": "code", "metadata": {}, "source": [ "class Shape:\n", " def __init__(self, sides):\n", " self.sides = sides\n", " \n", " @property\n", " def perimeter(self):\n", " return sum(self.sides)\n", " \n", " @property\n", " def area(self):\n", " pass\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "لاحظ استعمال **المعدِّل** (Decorator) `@property` (يعني: **خاصيَّة**) وهي تجعل طريقة الوصول لا تحتاج إلى قوسي استدعاء (`()`) كما هو الأصل.\n", "فبمجرد كتابة `.perimeter` فإن الطريقة تعمل لتأتيك بالنتيجة، وكأنها متغير.\n", "وهذا يستعمل في طرائق القراءة عادة، لا في طرائق الكتابة.\n", "\n", "والأمر الثاني هو استعمالنا كلمة `pass` وهي مثل الفراغ؛ ليس لها عمل إلا إقناع مفسر بايثون أننا لم نترك هذا المكان بالخطأ.\n", "والسبب في ترك هذه الطريقة فارغة هو أن الأنواع المستمدة ستجريها وإن كانت هنا مهملة.\n", "إذ ليس ثمة شيء هو شكلٌ فقط، ولذلك نعتبر هذا النوع، نوعًا **مُجرَّدًا** (Abstract)، إذ لن نستعمله مباشرةً أبدًا، بل سنخصصه أولاً.\n", "فأول نوع سيرث منه هو **المستطيل** (Rectangle).\n", "\n", "ولاحظ في `Rectangle` استعمال الإجراء الخاص `super()` وهو يشير إلى الموروث `Shape`؛ فيصير معنى الجملة ( `super().__init__()`) وكوْنها في أوَّل سطرٍ من جملة إجراء الإنشاء: الإنشاء فوق الإنشاء الموروث. \n" ] }, { "cell_type": "code", "metadata": {}, "source": [ "\n", "class Rectangle(Shape):\n", " def __init__(self, width, height):\n", " super().__init__((width, height, width, height))\n", " \n", " @property\n", " def width(self):\n", " return self.sides[0]\n", " \n", " @property\n", " def height(self):\n", " return self.sides[1]\n", " \n", " @property\n", " def area(self):\n", " return self.width * self.height\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "لاحظ القوسين الإضافيين حول المتغيرات المرسلة إلى الأب (`super().__init__()`)، وهذا يعني أنها كلها ستعيَّن للمعطى الأوَّل كصفّ (`tuple`)، وهو نوع تسلسل مثل القائمة لكنه جامد لا يقبل التغيير.\n", "\n", "أما **المربع**، فهو نوعٌ خاص من المستطيل:\n" ] }, { "cell_type": "code", "metadata": {}, "source": [ "class Square(Rectangle):\n", " def __init__(self, side):\n", " super().__init__((side, side))\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "وأما **المثلث**، فهو من الشكل:\n" ] }, { "cell_type": "code", "metadata": {}, "source": [ "\n", "class Triangle(Shape):\n", " def __init__(self, a, b, c):\n", " super().__init__((a, b, c))\n", "\n", " @property\n", " def a(self):\n", " return self.sides[0]\n", " \n", " @property\n", " def b(self):\n", " return self.sides[1]\n", " \n", " @property\n", " def c(self):\n", " return self.sides[2]\n", " \n", " @property\n", " def area(self):\n", " s = self.perimeter / 2\n", " return (s * (s - self.a) * (s - self.b) * (s - self.c))**0.5\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "والآن ستلاحظ إمكانية استعمال الشيئين المختلفين (المثلث والمستطيل) باعتبار المشترك بينهما (الشكل). ويتبين ذلك إذا كررنا عليهما في قائمة:\n" ] }, { "cell_type": "code", "metadata": {}, "source": [ "t = Triangle(10, 10, 10)\n", "r = Rectangle(10, 20)\n", "shapes = [t, r]\n", "\n", "for sh in shapes:\n", " print(sh.__class__.__name__)\n", " print(\"Perimeter:\", sh.perimeter)\n", " print(\"Area:\", round(sh.area, 2))\n", " print('='*40)\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "واستعمال `instance.__class__.__name__` يعطي اسم النوع الذي ينتمي إليه الشيء.\n", "\n", "لكنهما يفترقان في بعض الصفات إذ:\n", "\n", "- المستطيل له طول وعرض\n", "- المثلث له ثلاثة أضلاع\n", "\n", "ويمكن فحص النوع باستعمال الإجراء `isinstance(instance, class)` لمعرفة ما إذا كان الشيء ينتمي إلى ذلك النوع أو لا.\n" ] }, { "cell_type": "code", "metadata": {}, "source": [ "for sh in shapes:\n", " if isinstance(sh, Rectangle):\n", " print(f\"Sides: width={sh.width}, height={sh.height}\")\n", " elif isinstance(sh, Triangle):\n", " print(f\"Sides: a={sh.a}, b={sh.b}, c={sh.c}\")\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "وذلك ينطبق في تعريف الإجراءات. فإنك تستطيع تحديد النوع الأعم وتمرير النوع الأخص.\n", "\n", "فهو في التعريف عام:\n" ] }, { "cell_type": "code", "metadata": {}, "source": [ "def show(shape):\n", " print(shape.__class__.__name__)\n", " print(\"Perimeter:\", shape.perimeter)\n", " print(\"Area:\", round(shape.area, 2))\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "وفي التمرير خاص:\n" ] }, { "cell_type": "code", "metadata": {}, "source": [ "x = Triangle(10, 10, 10)\n", "show(x)\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n" ] }, { "cell_type": "code", "metadata": {}, "source": [ "y = Rectangle(10, 20)\n", "show(y)\n" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "للمزيد راجع [ملحق البرمجة الكائنية](appendix_oop.ipynb).\n" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.0" } }, "nbformat": 4, "nbformat_minor": 5 }