# الأنواع

وقد عرفنا أن من طرائق البرمجة (Programming Paradigms) في بايثون:

- الأمرية (Imperative): تعليمات ينفذها البرنامج بتسلسل
- الإجرائية (Procedural): إجراءات تستدعي إجراءات بشكل هرمي
- والآن نعرف أنها أيضًا **شيئية** (Object-oriented): أشياء لها صفات وأفعال وتفاعلات مع أشياء أخرى

<div class="text-center">
::::: columns
::: {.column width="50%"}
![الطرائق البرمجية: الشيئية، الأمرية، الإجرائية](../../assets/Venn_Programming_Paradigms_ar.jpg)
:::
::: {.column width="50%"}
![Programming Paradigms: Object-oriented, Procedural, Imperative](../../assets/Venn_Programming_Paradigms.jpg)
:::
:::::
</div>

وقد كنا نتعامل مع أشياء طيلة هذه الفترة؛ بدءًا بالرقم (`Number`) ومرورًا بفروعه: (`int`) و (`float`) و (`bool`)، مرورًا بالقائمة (`list`) والصف (`tuple`) والنطاق (`range`) والنص (`str`)، وكذلك المجموعة (`set`) والقاموس (`dict`).


```{mermaid}
graph TD
    A[<b>شيء</b> <br> <code>Object</code>] --> B[<b>رقم</b> <br> <code>Number</code>]
    B --> E[<b>صحيح</b> <br> <code>int</code>]
    B --> F[<b>عشري</b> <br> <code>float</code>]
    B --> G[<b>مركب</b> <br> <code>Complex</code>]
    A --> D[<b>جمع</b> <br> <code>Collection</code>]
    D --> M[<b>تسلسل</b> <br> <code>Sequence</code>]
    M --> C[<b>نص</b> <br> <code>str</code>]
    M --> H[<b>قائمة</b> <br> <code>list</code>]
    M --> I[<b>صف</b> <br> <code>tuple</code>]
    M --> J[<b>نطاق</b> <br> <code>range</code>]
    D --> K[<b>مجموعة</b> <br> <code>set</code>]
    D --> L[<b>قاموس</b> <br> <code>dict</code>]
```

وكل الأنواع من نوع **شيء** (Object). ثم تتفرع الأنواع وتتفرع. وقد يدخل النوع في أكثر من نوع بحسب الاعتبار (يأتي تفصيله). 

## البرمجة الشيئية

ففكرة **البرمجة الشيئية** تدور حول إسناد المتغيرات والإجراءات **لشيء** مُعَيَّنٍ من **نوع** ما.
ونشبه هذه الأشياء بالمحسوسات فيقال أنها أشياء ذات صفات وأفعال؛ إشارةً إلى المتغيرات والإجراءات المسندة إليها. ومن هذه الأفعال ما يكون بين الأشياء؛ فهو **تفاعل** بين نوع ونوع.

![الشيء](../../assets/Object_Capsule.png){fig-align="center" width=50%}

فمثلاً: نوع القائمة (`list`) يُنشأُ مِنهُ قائمة معيَّنة (هي الشيء: `xs = [1, 2, 3]`) يُسنَدُ إليها إجراءات الإضافة (`xs.append`) والحذف (`xs.remove`) والتعديل (`xs[i] = x`) ونحو ذلك.

والتفاعل قسمان:

الأول: **بين الشيء ومثيله** (من نفس النوع)؛ وذلك نحو تعريف: `list + list = list` بحيث تعرَّف علامة `+` بين الشيئين بعملية الدمج (لا الجمع). وكان من الممكن أن تعرَّف بأنها جمع.

الثاني: **بين الشيء وخلافه** (من نوع آخر)؛ وذلك نحو: `list.append(Any)` فإن القائمة تقبل في فعل الإلحاق (`append`) أي نوع. ويمكن تقييد النوع الذي يقبله الفعل كما كنا نفعل في الإجراءات؛ إذْ الأفعال ما هي إلا إجراءات مُسندة إلى نوع.

## تعريف النوع

الشيء: صفات وأفعال.

تأمل المثال التالي:

```{python}
class Counter:
    def __init__(self, count):
        self.count = count
    
    def increment(self, by=1):
        self.count += by
```

- **النوع** (Class): `Counter`
- **الصفات** (Properties): فقط `count`
- **الأفعال** (Methods): `increment`

لاحظ:

- يتم إسناد المتغيرات للمعيَّن في فعل الإنشاء `__init__`
- تتقدَّم `self` (نفس) كعامل في الابتداء في جميع الأفعال؛ وهي تشير إلى الشيء المعيَّن (Instance) ؛ أي: أحد أفراد النوع.

### إنشاء المعيَّنات

**المعيَّن**: أحد أفراد النوع.

ويسمى الفعل المخصوص [`__init__`](https://docs.python.org/3/reference/datamodel.html#object.__init__) بفعل الإنشاء (Initialization). وذلك أنه يتم تنفيذه عند استدعاء النوع هكذا:

```{python}
c1 = Counter(10)
```

ونشير للصفة بعلامة النقطة: `c1.count` والفعل كذلك: `c1.increment()` على النحو التالي:

```{python}
print(c1.count)
c1.increment(2)
c1.increment(3)
print(c1.count)
```

وهذا معيَّن آخر من نفس النوع:

```{python}
c2 = Counter(0)

print(c1.count)
print(c2.count)
```

## التغليف

![التغليف](../../assets/encapsulation.png){width=50%}

[**التغليف** (Encapsulation)](https://en.wikipedia.org/wiki/Encapsulation_(computer_programming)) آلية لإخفاء عمليات تفصيلية معقدة على البيانات المكنونة خلف إجراءات بسيطة.

فحينما عرفنا المتغير كصفة: `count` في الشيء `Counter`، أبرزنا من الإجراءات: `increment` فقط. وكأننا نقول: لا يمكن أن يعدِّل المستفيد على المتغير `count` إلا عن طريق الإجراء `increment`.
وصحيح أنك تستطيع الوصول من الخارج إلى صفة المعيَّن: `c1.count` لتعديلها مباشرةً، إلا أن ذلك يخالف آلية التغليف.

في المثال التالي لا نريد للمستفيد أن يعدِّل على الرصيد `balance` إلا عن طريق الإجراء `deposit` الذي يضمن أمرين:

- **قبليات** (pre-conditions): كاشتراط أن الزيادة تكون موجبة قبل البدء
- **بعديات** (post-conditions): ضمان تسجيل تاريخ العملية بعد التمام

يتم ذلك في بايثون عن طريق جعل الصفة نفسها (`balance`) **مخفيَّة**، ونبدلها بصفة **محميَّة**: `__balance` بشرطتين سفليتين متقدِّمة. ثم نُبرِزُ الصفة عن طريق فعل قراءة؛ وذلك باستعمال **المعدِّل** `@property`، وهو يجعل الفعل `balance` يبرز كصفة بلا قوسين للاستدعاء `balance()`  وذلك يعني أن مجرَّد عملية الوصول إلى الصفة (بعلامة النقطة: `.`) هو في الحقيقة استدعاء لفعل يعود بقيمة، لا بالصفة التي يمكن تعديلها.

```{python}
class Account:
    def __init__(self, name, balance):
        self.name = name
        self.__balance = balance

    # الإيداع
    def deposit(self, amount):
        # قبليات الإيداع
        if amount <= 0:
            print("must be positive")
            return
        
        # الإيداع نفسه
        self.__balance += amount

        # بعديات الإيداع
        print('time of deposit:', '2027-07-07')

    @property
    def balance(self):
        return self.__balance
```

نقوم الآن بإنشاء هذا الشيء الذي يمثِّل حساب المستخدم (`Account`)، ثم نصِل إلى الصفة بعلامة النقطة: `a1.balance`؛ فيكون ذلك استدعاءً للإجراء الذي تم وضع المعدِّل `@property` عليه ليكون الوصول إليه كالصفة:

```{python}
a1 = Account('Adam', 100)
a1.balance
```

ولو حاولت التغيير مباشرة على الصفة فإنك أصلاً لن تجد اسمها مُسندًا إلى الشيء:

```{python}
#|error: true
a1.balance = 1000
```

لكن يجوز فقط قراءة الصفة (قيمتها) لا التعديل عليها، هكذا (بعد الإيداع مثلاً):
```{python}
a1.deposit(100)
a1.balance
```

وليظهر أثر الحماية، نجرِّب إيداع مبلغ سالب، ولاحظ رسالة الخطأ:

```{python}
a1.deposit(-44)
```

وهكذا نتصوَّر الشيء كأنه آلة مزوَّّدة بآليات عامَّة يسهل استعمالها في ظروف كثيرة بحيث تغير هذه الآليات من حالة الشيء في كل مرة ليؤدي وظائف معقَّدة لا تتم بسهول بمجرَّد إجراء ذو خطوات محددة دائمًا بتسلسل واحد.

## العرض

نريد أن نعرِّف نوعًا جديدًا للإحداثيات (Point) ونريد أن نعرضها في جملة `print` بتمثيل يعبِّر عنها كإحداثيات.

يستعمل الفعل الخاص [`__repr__`](https://docs.python.org/3/reference/datamodel.html#object.__repr__)، ويعني **التمثيل** (Representation) لتخصيص طريقة عرض الشيء؛ سواءٌ إذا تم تمرير في `print` أو في آخر سطر من الخلية.
كل ما عليك هو إعادة قيمة نصيَّة من ذلك الفعل.

```{python}
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def move(self, dx, dy):
        self.x += dx
        self.y += dy
    
    def __repr__(self):
        return f"Point({self.x}, {self.y})"
```

والآن إن عرفنا نقطة جديدة، ووضعناها على السطر لوحدها ، ستظهر لنا الإحداثيات، لا عنوانها في الذاكرة:

```{python}
p = Point(3, 4)
p.move(7, 6)
p
```

## الإجراء الثابت

**الإجراء الثابت**: هو الإجراء المسند إلى النوع لا للمعيَّن.

فيمكن إسناد الإجراء للجنس لا للشيء الواحد، وذلك بإضافة المعدِّل `@staticmethod` عليه.
ونمثل لذلك بإجراء حساب المسافة بين نقطتين: `distance`. ولاحظ عدم وجود `self` فيه:

```{python}
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __repr__(self):
        return f"Point({self.x}, {self.y})"
    
    @staticmethod
    def distance(p1, p2, distance_type='euclidean'):
        if distance_type == 'euclidean':
            return ((p1.x - p2.x)**2 + (p1.y - p2.y)**2)**0.5
        elif distance_type == 'manhattan':
            return abs(p1.x - p2.x) + abs(p1.y - p2.y)
```

ثم يستعمل كأي إجراء، لكن بإسناده إلى النوع:

```{python}
p1 = Point(3, 4)
p2 = Point(7, 6)
d = Point.distance(p1, p2, 'manhattan')
print('distance:', d)
```

## المتغير الثابت

**المتغير الثابت**: هو المتغير المسند إلى النوع لا للمعيَّن.

يُسنَد المتغير للنوع بتعيينه بمحاذاة غيره من الإجراءات نحو ما فعلنا هنا بالمتغير `decor`. ولاحظ استعماله في الإجراء `__repr__` في جملة `if-else` من غير استعمال `self` لأننا لا نشير إلى معيَّن.

```{python}
class Point:
    decor = '<>'

    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def move(self, dx, dy):
        self.x += dx
        self.y += dy
    
    def __repr__(self):
        if Point.decor == '<>':
            return f"<{self.x}, {self.y}>"
        elif Point.decor == '[]':
            return f"[{self.x}, {self.y}]"
        else:
            return f"({self.x}, {self.y})"
```

فيمكن الآن تعديل المتغير `decor` للنوع:

```{python}
p1 = Point(3, 4)
p2 = Point(7, 6)
print(p1, p2)

Point.decor = '[]'
print(p1, p2)
```

## هيكل البيانات

تختلف كفاءة استرجاع البيانات وكتابتها والتعديل عليها بحسب شكل هذه البيانات في الذاكرة وشكلها على جهاز التخزين فعليًّا. وهذا ما نسميه **بهيكلة البيانات** (Data Structure). ومن أمثلة ذلك:

- المصفوفة (Array)
- الشجرة (Tree)
- الرسم (Graph)

وغيرها كثير. وسنمثل على ذلك  بتشكيل الكومة في بايثون:


### الكومة (`Stack`)

نريد أن نعرِّف نوعًا من **هياكل البيانات** يسمى **الكومة** (Stack)، وكأنه يمثِّل مجموعة مكدسة من الأوراق؛ إذ له فعلين:

- وضع ورقة: `push(item)` وكأنك تضع ورقة فوق الأوراق السابقة
- سحب ورقة: `pop()` وكأنك تسحب ورقةً من الأعلى
- لمحة سريعة: `peek()` وكأنك تنظر إلى الورقة العليا دون سحبها

وأقرب شيء له في بايثون هو القائمة (`list`) ولذلك ستكون هي تمثيلها الداخلي.

```{python}
class Stack:
    def __init__(self):
        self.items = []

    def push(self, item):
        self.items.append(item)
    
    def pop(self):
        return self.items.pop()
    
    def peek(self):
        return self.items[-1]

    def __repr__(self):
        return f"|{'|'.join(str(item) for item in self.items)}>"
```

- فعل الإنشاء يُسنِد قائمة فارغة إلى الشيء (`self`)
- فعل `push` يضيف إلى آخر هذه القائمة بالفعل `append`
- فعل `pop` يأخذ آخر عنصر من القائمة بالفعل `pop` (وهو إزالة مع أخذ)
- فعل `__repr__` يعطينا تمثيلاً للكومة بالاعتماد على تمثيل القائمة

نجرب الآن أن ننشئها ثم نضع أربعة عناصر فيها ونظهرها:

```{python}
s = Stack()
s.push(10)
s.push(20)
s.push(30)
s.push(400)
print(s)
```

والآن نسحب عنصرًا (من الأخير)، ونظهرها:

```{python}
s.pop()
print(s)
```

ويمكن النظر في العنصر الأعلى دون سحبه بالفعل `peek`:

```{python}
print(s.peek())
```

