# عوامل Python: الحساب و// و%، والمقارنة وand/or/not، ودالة python round

URL: https://skillaria.top/ar/guides/python/python-operators-round

العامل / في Python يعطي دائماً float، و// يعطي الجزء الصحيح مع التقريب للأسفل، و% يعطي الباقي، و** هو الأس. الدالة round(x, n) تقرّب إلى n منزلة بالطريقة المصرفية: round(2.5) تعطي 2 وround(3.5) تعطي 4، وللتقريب للأعلى والأسفل إلى عدد صحيح تُستخدم math.ceil وmath.floor، والقيمة المطلقة تعطيها abs.

عوامل Python رموز تحوّل القيم إلى قيم جديدة: `+` تجمع، و`//` تقسم قسمة صحيحة، و`and` تربط الشروط. فيما يلي قائمة كاملة بالعوامل مع أمثلة، والفرق بين `/` و`//`، ومنطق `and` و`or` و`not`، وكذلك دوال التقريب: دالة python round، و`math.ceil`، و`math.floor`، و`abs`. يمكنك لصق كل الأمثلة في الوحدة التفاعلية REPL وتجربتها.

## قائمة عوامل Python

تنقسم العوامل حسب وظيفتها. لا حاجة إلى حفظ الجدول كله: في الكود الواقعي تتكرر العمليات الحسابية والمقارنة والروابط المنطقية أكثر من غيرها.

| المجموعة | العوامل | مثال |
| --- | --- | --- |

| الحسابية | `+ - * / // % **` | `7 // 2` ← 3 |

| المقارنة | `== != < > <= >=` | `3 < 5` ← True |

| المنطقية | `and or not` | `not True` ← False |

| الهوية | `is`، `is not` | `x is None` |

| الانتماء | `in`، `not in` | `"ق" in "قهوة"` ← True |

| التعيين | `= += -= *= /= //= %= **=` | `total += 250` |

| المعامل الحيتاني | `:=` | `if (n := len(s)) > 10:` |

| البتية (Bitwise) | `& | ^ ~ << >>` | `5 & 3` ← 1 |

## العوامل الحسابية

الجمع والطرح والضرب تعمل كما في المدرسة. وإذا دخل في التعبير عدد `float` واحد على الأقل فالنتيجة أيضاً `float`: فـ `2 + 1.0` تعطي `3.0`. والأعداد الصحيحة في Python لا تفيض عن حدها: فالعدد `2 ** 100` يُحسب بدقة مهما بلغت عدد خاناته.

```
>>> 250 + 120
370
>>> 12.5 * 3
37.5
>>> 2 ** 10
1024
>>> 2 ** 0.5
1.4142135623730951
```

### الأس في Python: العامل **

رفع الأس يتم بنجمتين وليس بالرمز `^`، لأن الرمز `^` في Python يعني «XOR» البتي، فـ `2 ^ 3` تعطي 1 لا 8. والأس الكسري يعطي جذراً: فـ `9 ** 0.5` تساوي `3.0`. وتوجد الدالة `pow(x, y)` وهي المكافئ نفسه، مع وسيط ثالث للباقي: `pow(2, 10, 1000)` تعطي 24.

انتبه إلى الأولوية: العامل `**` يُنفَّذ قبل السالب الأحادي، لذلك `-2 ** 2` تساوي `-4`. وإذا أردت مربع عدد سالب فاكتب الأقواس: `(-2) ** 2`.

## القسمة في Python: /، و// و%

في Python نوعان من القسمة، وهذا أكبر مصدر للمفاجآت عند المبتدئين. القسمة العادية `/` تعطي دائماً `float`، حتى لو كانت القسمة تامة. أما القسمة الصحيحة `//` فتُسقط الجزء الكسري، والعامل `%` يعطي الباقي.

```
>>> 7 / 2
3.5
>>> 8 / 2
4.0
>>> 7 // 2
3
>>> 7 % 2
1
```

### القسمة الصحيحة // والباقي %: من التطبيق

الزوج `//` و`%` يحل مسائل مثل «كم عدداً صحيحاً وكم بقي». في الدورة يحفظ متتبع المصروفات المبالغ بالفلس (أصغر وحدة) حتى لا تضيع الدقة، ويفصل المبلغ إلى دنانير وفلوس:

```
fils = 125050             # نخزّن المبالغ بالفلس
dinars = fils // 100      # 1250 — الدنانير الكاملة
rest = fils % 100         # 50 — الباقي
print(dinars, rest)       # 1250 50

print(40 // 7, "أسابيع و", 40 % 7, "أيام")   # 5 أسابيع و 5 أيام
```

تعيد الدالة المدمجة `divmod` العمليتين معاً: `divmod(125050, 100)` تعطي الصف `(1250, 50)`. والباقي مفيد أيضاً لمعرفة الزوجية: العبارة `n % 2 == 0` صحيحة للأعداد الزوجية.

### الأعداد السالبة: // يقرّب للأسفل

العامل `//` لا يكتفي بإسقاط الكسر، بل يقرّب للأسفل، أي نحو سالب ما لا نهاية. مع الأعداد الموجبة لا فرق، أما مع السالبة فهناك فرق. وإشارة الباقي `%` في Python تطابق إشارة المقسوم عليه، لذلك يتحقق دائماً أن `a == (a // b) * b + a % b`.

```
>>> -7 // 2
-4
>>> -7 % 2
1
>>> int(-7 / 2)     # إسقاط الكسر لا التقريب للأسفل
-3
```

### القسمة على صفر: أي خطأ يظهر

القسمة على صفر بأي عامل من الثلاثة تُطلق الاستثناء `ZeroDivisionError`، وهذا يشمل الأعداد الصحيحة والكسرية. ويمكن التقاطه بـ `try/except` أو فحص المقسوم عليه مسبقاً.

```
>>> 10 / 0
Traceback (most recent call last):
  ...
ZeroDivisionError: division by zero
>>> count = 0
>>> avg = 1500 / count if count else 0
>>> avg
0
```

## عوامل المقارنة

تُعيد المقارنات القيمة `True` أو `False`. يُفحص التساوي بالرمز المزدوج `==`، أما الرمز المفرد `=` فهو تعيين. والنصوص تُقارن حرفاً حرفاً حسب رموز الأحرف، لذلك فـ `"B" < "a"` صحيحة: الأحرف الكبيرة تأتي قبل الصغيرة.

```
>>> 250 == 250.0
True
>>> 3 != 4
True
>>> 1 < 5 > 0.1 + 0.2 == 0.3
False
```

سلاسل المقارنة مثل `0 <= x < 100` ميزة مريحة في Python، فلا حاجة إلى كتابة `and`. والسطر الأخير يذكّر بخطأ الأعداد الكسرية: `0.1 + 0.2` تعطي `0.30000000000000004`. قارن الأعداد الكسرية بـ `math.isclose(a, b)`، واحفظ المبالغ المالية بالفلس أو باستخدام `Decimal`.

## العوامل المنطقية and وor وnot

تُكتب العوامل المنطقية في Python كلمات لا رموزاً مثل `&&` و`||` كما في لغات أخرى. فـ `and` صحيحة عندما يكون الطرفان صحيحين، و`or` عندما يكون أحدهما صحيحاً على الأقل، و`not` تقلب القيمة.

| a | b | a and b | a or b | not a |
| --- | --- | --- | --- | --- |

| True | True | True | True | False |

| True | False | False | True | False |

| False | True | False | True | True |

| False | False | False | False | True |

الأولوية: أولاً `not`، ثم `and`، ثم `or`. فالتعبير `True or False and False` يساوي `True` لأن `and` تُحسب أولاً. وفي الشروط المعقدة ضع أقواساً، فهذا أوضح لك ولزملائك.

### ماذا تعيد and وor فعلاً

`and` و`or` لا تعيدان بالضرورة `True` أو `False`، بل تعيدان أحد المعاملين. فـ `or` تعطي أول قيمة صحيحة (أو الأخيرة إن لم توجد صحيحة)، و`and` تعطي أول قيمة خاطئة (أو الأخيرة). والقيم الخاطئة هي `0` و`0.0` والنص الفارغ والمجموعات الفارغة و`None` و`False`.

```
>>> name = ""
>>> name or "ضيف"
'ضيف'
>>> 5 and 0
0
>>> not ""
True
```

الحساب كسول: إذا تحدد الناتج من الطرف الأيسر فلا يُحسب الطرف الأيمن. لذلك لن يسقط `count and total / count` بخطأ القسمة على صفر عندما يكون `count == 0`. والعامل `not` وحده يعيد دائماً قيمة من نوع `bool`.

## العاملان is وin

`==` تقارن القيم، أما `is` فتتحقق أن الاسمين يشيران إلى الكائن نفسه. سلتان فارغتان متساويتان لكنهما ليستا كائناً واحداً. والموضع الوحيد الذي تحتاج فيه إلى `is` باستمرار هو التحقق من `None`: `if x is None`.

```
>>> a = [250, 120]
>>> b = [250, 120]
>>> a == b, a is b
(True, False)
>>> c = a
>>> c is a
True
```

لا تقارن الأعداد والنصوص بـ `is`: أحياناً «يعمل» ذلك بسبب التخزين المؤقت الداخلي للكائنات، لكن النتيجة تعتمد على التطبيق، وتُظهر Python تحذير `SyntaxWarning` على تراكيب مثل `x is 5`.

العامل `in` يتحقق من الاحتواء: نص داخل نص، أو عنصر داخل قائمة، أو مفتاح داخل قاموس. و`not in` هو العكس.

```
>>> "قهوة" in "قهوة مع النقل"
True
>>> "طعام" in {"طعام": 450, "تاكسي": 300}
True
>>> 5 not in [1, 2, 3]
True
```

## عوامل التعيين والمعامل الحيتاني :=

العوامل المركبة `+=` و`-=` و`*=` و`//=` وغيرها اختصار: فـ `total += 250` تعني `total = total + 250`. ولا توجد في Python العوامل `++` و`--`: فـ `x++` تسبب خطأ صياغياً.

المعامل الحيتاني `:=` (سُمّي كذلك لشبهه بعيني الفظ وأنيابه) يعيّن قيمة داخل التعبير نفسه. وهو مفيد عندما تحتاج إلى القيمة للفحص ثم للاستخدام:

```
items = ["قهوة", "تاكسي", "غداء", "سينما"]
if (n := len(items)) > 3:
    print(f"مصروفات كثيرة: {n}")

while (line := input("المبلغ: ")) != "":
    print(int(line) * 2)
```

بدونه كان سيلزم استدعاء `len` مرتين أو وضع التعيين في سطر منفصل. ولا ينبغي الإفراط في استخدامه: إذا صار السطر غير مقروء فالتعيين العادي أفضل.

## التقريب في Python: round وceil وfloor

للتقريب في Python دالة مدمجة هي `round`، ودوال في الوحدة `math`. وهي تحل مسائل مختلفة، والخلط بينها خطأ شائع.

| الدالة | ماذا تفعل | 2.5 | -2.5 | 2.7 |
| --- | --- | --- | --- | --- |

| `round(x)` | إلى الأقرب، والمنتصف إلى الزوجي | 2 | -2 | 3 |

| `math.floor(x)` | للأسفل، نحو سالب ما لا نهاية | 2 | -3 | 2 |

| `math.ceil(x)` | للأعلى، نحو موجب ما لا نهاية | 3 | -2 | 3 |

| `math.trunc(x)`، `int(x)` | إسقاط الكسر، نحو الصفر | 2 | -2 | 2 |

### دالة round في Python والتقريب المصرفي

الدالة `round(x, n)` تقرّب إلى `n` منزلة بعد الفاصلة، وإذا لم تُذكر `n` تعيد عدداً صحيحاً `int`. وأهم فخ هنا: python round يقرّب «بالطريقة المصرفية»، أي المنتصف إلى الزوجي. لذلك فـ `round(2.5)` تعطي 2، و`round(3.5)` تعطي 4. وبهذا لا تتراكم أخطاء التقريب في اتجاه واحد عند الحسابات الكبيرة.

```
>>> round(2.5), round(3.5)
(2, 4)
>>> round(3.14159, 2)
3.14
>>> round(1250, -2)     # إلى أقرب مئة
1200
>>> round(2.675, 2)     # ليس 2.68: في النظام الثنائي هو 2.67499...
2.67
```

إذا أردت التقريب المدرسي المعتاد «المنتصف إلى الأعلى»، مثلاً في الفاتورة، فاستخدم `Decimal` مع الوضع `ROUND_HALF_UP`. مرّر الرقم كنص كي لا ترث خطأ `float`:

```
>>> from decimal import Decimal, ROUND_HALF_UP
>>> Decimal("2.5").quantize(Decimal("1"), ROUND_HALF_UP)
Decimal('3')
>>> Decimal("2.675").quantize(Decimal("0.01"), ROUND_HALF_UP)
Decimal('2.68')
```

وقاعدة أخرى من الدورة: قرّب فقط عند العرض. للطباعة الأنيقة لا حاجة إلى `round`، فيكفي نص f-string: `f"{amount:.2f}"` يعرض منزلتين، والقيمة نفسها تبقى دقيقة.

### math.ceil وmath.floor: التقريب للأعلى والأسفل

تحتاج `math.ceil` عندما لا يجوز أن «ينقص» شيء: كم حافلة نطلب، وكم صفحة تلزم للنتائج. أما `math.floor` فيُستخدم عندما تُحسب الوحدات الكاملة فقط. وكلتاهما تعيدان `int`.

```
import math

guests = 47
seats = 20
print(math.ceil(guests / seats))   # 3 حافلات
print(math.floor(9.99))            # 9
print(-(-guests // seats))         # 3 — ceil بدون math، بحيلة //
```

في الوحدة `math` دوال مفيدة أخرى: `math.sqrt` (الجذر)، و`math.isclose` (مقارنة الكسور)، و`math.pi`، و`math.gcd`. وظهرت في Python 3.15 وحدة فرعية `math.integer` (PEP 791) للرياضيات الصحيحة، فيها `comb` و`factorial` و`gcd` و`isqrt` و`lcm` و`perm`، بينما تستمر الدوال القديمة مثل `math.gcd` في العمل.

## الدالة abs: القيمة المطلقة

`abs(x)` تعيد القيمة المطلقة، أي البعد عن الصفر دون إشارة. لا تحتاج إلى استيراد، فهي دالة مدمجة. وتعمل مع الأعداد الصحيحة والكسرية وحتى المركبة: مع `3+4j` تعيد طول المتجه، أي `5.0`.

```
>>> abs(-250)
250
>>> abs(-12.5)
12.5
>>> budget, spent = 5000, 5320
>>> abs(budget - spent)    # بكم انحرفنا
320
```

الاستخدام النموذجي هو الفرق بغض النظر عن الاتجاه، والمقارنة مع هامش خطأ: `abs(a - b) < 0.001`. ومع الكسور تكون `math.isclose` أدق، لأنها تأخذ حجم الأعداد في الحسبان.

## أولوية العوامل

حين يحتوي التعبير على عدة عوامل ينفذ Python بحسب الأولوية، من الأعلى إلى الأدنى:

1. `**`
2. العوامل الأحادية `-x` و`+x` و`~x`
3. `* / // %`
4. `+ -`
5. إزاحات البتات والعمليات البتية
6. المقارنات، و`in`، و`is`
7. `not`
8. `and`
9. `or`
10. `:=`

فـ `2 + 3 * 4` تساوي 14، و`(2 + 3) * 4` تساوي 20. وإذا شككت فضع أقواساً: الأقواس الزائدة لا تكلّف شيئاً، أما خطأ الأولوية فيستغرق وقتاً طويلاً للعثور عليه.

## أخطاء شائعة مع العوامل

| الخطأ | ما الذي يحدث | الصواب |
| --- | --- | --- |

| `if x = 5:` | SyntaxError: هذا تعيين | `if x == 5:` |

| `2 ^ 3` بدلاً من الأس | XOR بتي، والنتيجة 1 | `2 ** 3` |

| انتظار عدد صحيح من `8 / 2` | تحصل على `4.0` | `8 // 2` |

| `x == 1 or 2` | صحيحة دائماً: `or 2` | `x in (1, 2)` |

| انتظار 3 من `round(2.5)` | التقريب المصرفي يعطي 2 | `Decimal` مع `ROUND_HALF_UP` |

| `"5" + 5` | TypeError | `int("5") + 5` |

## الخلاصة

تذكّر الأساسيات: `/` تعطي دائماً float، و`//` تقرّب للأسفل، و`%` تعيد الباقي بإشارة المقسوم عليه، والأس هو `**`. العوامل المنطقية `and` و`or` و`not` تُكتب كلمات وتُحسب بالكسل، و`is` تُستخدم للتحقق من `None`. دالة python round تقرّب إلى الزوجي، وللتقريب للأعلى والأسفل توجد `math.ceil` و`math.floor`، والقيمة المطلقة تعطيها `abs`. وفي الدورة تُشرح هذه العوامل عملياً في متتبع المصروفات، حيث تُحفظ المبالغ بالفلس.

## FAQ

**كيف أقرّب عدداً في Python إلى منزلتين عشريتين؟**

استخدم round(x, 2)، وإذا أردت العرض فقط فاستخدم f-string مثل f"{x:.2f}" الذي لا يغيّر القيمة نفسها.

**لماذا تعيد round(0.5) في Python القيمة 0؟**

لأن round تقرّب المنتصف إلى أقرب عدد زوجي، والصفر زوجي؛ وكذلك round(1.5) وround(2.5) تعطيان 2.

**كيف أحصل على الجزء الصحيح من القسمة في Python؟**

بالعامل //: فـ 17 // 5 تعطي 3. وهو مع الأعداد السالبة يقرّب للأسفل، فـ -17 // 5 تعطي -4؛ وإذا أردت إسقاط الكسر نحو الصفر فاستخدم int(-17 / 5).

**هل يوجد في Python عامل شرطي ثلاثي؟**

نعم، وهو التعبير الشرطي: قيمة_إذا_صح if الشرط else قيمة_إذا_خطأ، مثل "زوجي" if n % 2 == 0 else "فردي".

**ما الفرق بين & وand في Python؟**

and عامل منطقي بحساب كسول، أما & فهو AND البتي للأعداد والتقاطع للمجموعات؛ وفي الشروط استخدم and.


---
Source: Skillaria.Top (https://skillaria.top)