لا تخلو لغة برمجة من التعليمات الشرطية التي تُنفَّذ بناءً على تحقق شرط معين، وهي تعليمات برمجية يمكنها التحكم في تنفيذ شفرات معينة بحسب تحقق شرط ما من عدمه في وقت التنفيذ.

تُنفّذ تعليمات برامج بايثون من الأعلى إلى الأسفل، مع تنفيذ كل سطر بحسب ترتيبه. باستخدام التعليمات الشرطية، يمكن للبرامج التحقق من استيفاء شروط معينة، ومن ثم تنفيذ الشيفرة المقابلة.

هذه بعض الأمثلة التي سنستخدم فيها التعليمات الشرطية:

• إن حصلت الطالبة على أكثر من 65٪ في الامتحان، فأعلن عن نجاحها؛ وإلا، فأعلن عن رسوبها
• إذا كان لديه مال في حسابه، فاحسب الفائدة. وإلا، فاحسب غرامة
• إن اشتروا 10 برتقالات أو أكثر، فاحسب خصمًا بمقدار 5٪؛ وإلا فلا تفعل

تقيِّم الشيفرة الشرطية شروطًا، ثم تُنفِّذ شيفرةً بناءً على ما إذا تحققت تلك الشروط أم لا. ستتعلم في هذا الدرس كيفية كتابة التعليمات الشرطية في بايثون.

التعليمة if

سنبدأ بالتعليمة ‎if‎، والتي تتحقق مما إذا تحقق شرط محدَّد أم لا، وفي حال تحقق الشرط، فستنفَّذ الشيفرة المقابلة له.

لنبدأ بأمثلة عملية توضح ذلك. افتح ملفًا، واكتب الشيفرة التالية:

grade = 70

if grade >= 65:
    print("درجة النجاح")

أعطينا للمتغير ‎grade‎ القيمة ‎70‎. ثم استخدمنا التعليمة ‎if‎ لتقييم ما إذا كان المتغير grade أكبر من (‎>=‎) أو يساوي ‎65‎. وفي تلك الحالة، سيطبع البرنامج السلسلة النصية التالية: درجة النجاح.

احفظ البرنامج بالاسم ‎grade.py‎، ثم نفّذه في بيئة البرمجة المحلية من نافذة الطرفية باستخدام الأمر ‎python grade.py‎.

في هذه الحالة، الدرجة 70 تلبي الشرط، لأنّها أكبر من 65، لذلك ستحصل على المخرجات التالية عند تنفيذ البرنامج:

درجة النجاح

لنغيّر الآن نتيجة هذا البرنامج عبر تغيير قيمة المتغير ‎grade‎ إلى ‎60‎:

grade = 60

if grade >= 65:
    print("درجة النجاح")

بعد حفظ وتنفيذ الشيفرة، لن نحصل على أي مخرجات، لأنّ الشرط لم يتحقق، ولم نأمر البرنامج بتنفيذ تعليمة أخرى.

كمثال آخر، دعنا نتحقق مما إذا كان رصيد الحساب المصرفي أقل من 0. لننشئ ملفا باسم ‎account.py‎، ونكتب البرنامج التالي:

balance = -5

if balance < 0:
    print("الحساب فارغ، أضف مبلغا الآن، أو ستحصل على غرامة.")

عند تنفيذ البرنامج باستخدام ‎python account.py‎، سنحصل على المخرجات التالية:

الحساب فارغ، أضف مبلغًا الآن، أو ستحصل على غرامة.

أعطينا للمتغير ‎balance‎ القيمة ‎-5‎، وهي أقل من 0 في البرنامج السابق. ولمَّا كان الرصيد مستوفيًا لشرط التعليمة ‎if‎ (أي ‎balance < 0‎)، فسنحصل على سلسلة نصية في المخرجات بمجرد حفظ الشيفرة وتنفيذها. مرة أخرى، لو غيرنا الرصيد إلى القيمة 0 أو إلى عدد موجب، فلن نحصل على أيّ مخرجات.

دورة تطوير التطبيقات باستخدام لغة Python

احترف تطوير التطبيقات مع أكاديمية حسوب والتحق بسوق العمل فور انتهائك من الدورة

اشترك الآن

التعليمة Else

قد تريد من البرنامج أن يفعل شيئًا ما في حال عدم تحقق شرط التعليمة ‎if‎. في المثال أعلاه، نريد طباعة مخرجات في حال النجاح والرسوب. ولفعل ذلك، سنضيف التعليمة ‎else‎ إلى شرط الدرجة أعلاه وفق الصياغة التالية:

grade = 60

if grade >= 65:
    print("درجة النجاح")

else:
    print("درجة الرسوب")

قيمة المتغير ‎‎grade‎‎ تساوي ‎60‎، لذلك فشرط التعليمة ‎if‎ غير متحقق، وبالتالي فإنّ البرنامج لن يطبع ‎درجة النجاح‎. تخبر التعليمة ‎else‎ البرنامجَ أنّ عليه طباعة السلسلة النصية "درجة الرسوب".

عندما نحفظ البرنامج وننفّذه، سنحصل على المخرجات التالية:

درجة الرسوب

إذا عدّلنا البرنامج وأعطينا المتغيرَ grade القيمة ‎65‎ أو أعلى منها، فسنحصل بدلاً من ذلك على الناتج ‎درجة النجاح‎.

لإضافة التعليمة ‎else‎ إلى مثال الحساب المصرفي، سنعيد كتابة الشيفرة كما يلي:

balance = 522

if balance < 0:
    print("الحساب فارغ، أضف مبلغا الآن، أو ستحصل على غرامة.")

else:
    print("رصيدك أكبر من 0.")

سنحصل على المخرجات التالية:

رصيدك أكبر من 0.

هنا، غيّرنا قيمة المتغير ‎balance‎ إلى عدد موجب لكي تُنفَّذ الشيفرة المقابلة للتعليمة ‎else‎. إن أردت تنفيذ الشيفرة المقابلة للتعليمة ‎if‎، غيِّر القيمة إلى عدد سالب.

من خلال دمج العبارتين ‎if‎ و ‎else‎، فأنت تنشئ تعليمة شرطية مزدوجة، والتي ستجعل الحاسوب ينفذ شيفرة برمجية معينة سواء تم استيفاء شرط ‎if‎ أم لا.

التعليمة Else if

حتى الآن، عملنا على تعليمات شرطية ثنائية، أي إن تحقق الشرط، فنفذ شيفرة ما، وإلا، فنفِّذ شيفرة أخرى فقط. لكن في بعض الحالات، قد تريد برنامجًا يتحقق من عدة حالات شرطية. ولأجل هذا، سوف نستخدم التعليمة Else if، والتي تُكتب في بايثون هكذا ‎elif‎. تشبه التعليمة ‎elif‎ - أو Else if - التعليمة ‎if‎، ومهمتها التحقق من شرط إضافي.

في برنامج الحساب المصرفي، قد نرغب في الحصول على ثلاثة مخرجات مختلفة مقابلة لثلاث حالات مختلفة:

• الرصيد أقل من 0
• الرصيد يساوي 0
• الرصيد أعلى من 0

ستوضع التعليمة ‎elif‎ بين التعليمة ‎if‎ والتعليمة ‎else‎ كما يلي:

. . .
if balance < 0:
    print("الحساب فارغ، أضف مبلغا الآن، أو ستحصل على غرامة.")

elif balance == 0:
    print("الرصيد يساوي 0، أضف مبلغًا قريبًا.")

else:
    print("رصيدك أكبر من 0.")

الآن، هناك ثلاثة مخرجات محتملة يمكن أن تُطبع عند تنفيذ البرنامج:

• إن كان المتغير ‎balance‎ يساوي ‎0‎، فسنحصل على المخرجات من التعليمة ‎elif‎ (أي ‎الرصيد يساوي 0، أضف مبلغًا قريبًا.‎).
• إذا ضُبِط المتغير ‎balance‎ عند عدد موجب، فسوف نحصل على المخرجات من التعليمة ‎else‎ (أي ‎رصيدك أكبر من 0.‎).
• إذا ضُبِط المتغير ‎balance‎ عند عدد سالب، فسنحصل على المخرجات من التعليمة ‎if‎ (أي ‎الحساب فارغ، أضف مبلغا الآن، أو ستحصل على غرامة‎).

ماذا لو أردنا أن نأخذ بالحسبان أكثر من ثلاثة احتمالات؟ يمكننا كتابة عدة تعليمات ‎elif‎ في الشيفرة البرمجية.

لنُعِد كتابة البرنامج ‎grade.py‎ بحيث يقابل كل نطاق من الدرجات علامة محددة:

• 90 أو أعلى تكافئ العلامة أ
• 80-89 تعادل العلامة ب
• 70-79 تعادل العلامة ج
• 65-69 تعادل العلامة د
• 64 أو أقل تكافئ العلامة ه

سنحتاج لتنفيذ هذه الشيفرة إلى تعليمة ‎if‎ واحد، وثلاث تعليمات ‎elif‎، وتعليمة ‎else‎ تعالج جميع الحالات الأخرى.

دعنا نعيد كتابة الشيفرة من المثال أعلاه لطباعة سلسلة نصية مقابلة لكل علامة. يمكننا الإبقاء على التعليمة ‎else‎ كما هي.

. . .
if grade >= 90:
    print("العلامة أ")

elif grade >=80:
    print("العلامة ب")

elif grade >=70:
    print("العلامة ج")

elif grade >= 65:
    print("العلامة د")

else:
    print("درجة الرسوب")

تُنفّذ التعليمات ‎elif‎ بالترتيب. هذا البرنامج سيكمل الخطوات التالية:

• إذا كانت الدرجة أكبر من 90، فسيطبع البرنامجُ ‎العلامة أ‎، وإذا كانت الدرجة أقل من 90، فسيمرّ البرنامج إلى التعليمة التالية …
• إذا كانت الدرجة أكبر من أو تساوي 80، فسيطبع البرنامجُ ‎العلامة ب‎، إذا كانت الدرجة تساوي 79 أو أقل، فسيمرّ البرنامج إلى التعليمة التالية …
• إذا كانت الدرجة أكبر من أو تساوي 70، فسيطبعُ البرنامجُ ‎العلامة ج‎، إذا كانت الدرجة تساوي 69 أو أقل، فسيمرّ البرنامج إلى التعليمة التالية …
• إذا كانت الدرجة أكبر من أو تساوي 65، فسيطبع البرنامجُ ‎العلامة د‎، وإذا كانت الدرجة تساوي 64 أو أقل، فسيمرّ البرنامج إلى التعليمة التالية …
• سيطبع البرنامج ‎درجة الرسوب‎، لأنه لم يتم استيفاء أيِّ من الشروط المذكورة أعلاه.

تعليمات if المتشعبة

بعد أن تتعود على التعليمات ‎if‎ و ‎elif‎ و ‎else‎، يمكنك الانتقال إلى التعليمات الشرطية المتشعبة (nested conditional statements).

يمكننا استخدام تعليمات ‎if‎ المتشعبة في الحالات التي نريد فيها التحقق من شرط ثانوي بعد التأكد من تحقق الشرط الرئيسي. لهذا، يمكننا حشر تعليمة if-else داخل تعليمة if-else أخرى. لنلقِ نظرة على صياغة ‎if‎ المتشعبة:

if statement1:              # الخارجية if تعليمة
    print("true")

    if nested_statement:    # المتشعبة if تعليمة
        print("yes")

    else:                   # المتشعبة else تعليمة
        print("no")

else:                       # الخارجية else تعليمة
    print("false")

هناك عدة مخرجات محتملة لهذه الشيفرة:

• إذا كانت ‎statement1‎ صحيحة، فسيتحقق البرنامج مما إذا كانت ‎nested_statement‎ صحيحة أيضًا. إذا كانت كلتا الحالتين صحيحتان، فسنحصل على المخرجات التالية:

true
yes

• ولكن إن كانت ‎statement1‎ صحيحة، و ‎nested_statement‎ خاطئة، فسنحصل على المخرجات التالية:

true
no

• وإذا كانت ‎statement1‎ خاطئة، فلن تُنفّذ تعليمة if-else المتشعبة على أيّ حال، لذلك ستُنفّذ التعليمة ‎else‎ وحدها، والمخرجات ستكون:

false

يمكن أيضًا استخدام عدة تعليمات ‎if‎ متشعبة في الشيفرة:

if statement1:                  # الخارجية if 
    print("hello world")

    if nested_statement1:       # المتشعبة الأولى if 
        print("yes")

    elif nested_statement2:     # المتشعبة الأولى elif
        print("maybe")

    else:                       #المتشعبة الأولى  else
        print("no")

elif statement2:                # الخارجية elif
    print("hello galaxy")

    if nested_statement3:       # المتشعبة الثانية if
        print("yes")

    elif nested_statement4:     # المتشعبة الثانية elif
        print("maybe")

    else:                       # المتشعبة الثانية else
        print("no")

else:                           # الخارجية else
    statement("مرحبا")

في الشيفرة البرمجية أعلاه، هناك تعليمات ‎if‎ و ‎elif‎ متشعبة داخل كل تعليمات ‎if‎. هذا سيفسح المجال لمزيد من الخيارات في كل حالة.

دعنا نلقي نظرة على مثال لتعليمات ‎if‎ متشعبة في البرنامج ‎grade.py‎. يمكننا التحقق أولًا مما إذا كان الطالب قد حقق درجة النجاح (أكبر من أو تساوي 65٪)، ثم نحدد العلامة المقابلة للدرجة. إذا لم يحقق الطالب درجة النجاح، فلا داعي للبحث عن العلامة المقابلة للدرجة، وبدلًا من ذلك، يمكن أن نجعل البرنامج يطبع سلسلة نصية فيها إعلان عن رسوب الطالب. ستبدو الشيفرة المعدلة كما يلي:

. . .
if grade >= 65:
    print("درجة النجاح:")

    if grade >= 90:
        print("أ")

    elif grade >=80:
        print("ب")

    elif grade >=70:
        print("ج")

    elif grade >= 65:
        print("د")

else:
    print("درجة الرسوب")

إذا أعطينا للمتغير ‎grade‎ القيمة ‎92‎، فسيُستوفى الشرط الأول، وسيَطبع البرنامجُ ‎درجة النجاح:‎. بعد ذلك، سيتحقق مما إذا كانت الدرجة أكبر من أو تساوي 90، وبما أنّ هذا الشرط مستوفًى أيضًا، فستُطبع ‎أ‎.

أما إذا أعطينا للمتغير ‎grade‎ القيمة ‎60‎، فلن يتم استيفاء الشرط الأول، لذلك سيتخطى البرنامج تعليمات ‎if‎ المتشعبة، وينتقل إلى التعليمة ‎else‎، ويطبع ‎درجة الرسوب‎.

يمكننا بالطبع إضافة المزيد من الخيارات، واستخدام طبقة ثانية من تعليمات if المتشعبة. ربما نود إضافة الدرجات التفصيلية أ+‎ و أ و أ-‎. يمكننا القيام بذلك عن طريق التحقق أولًا من اجتياز درجة النجاح، ثم التحقق مما إذا كانت الدرجة تساوي 90 أو أعلى، ثم التحقق مما إذا كانت الدرجة تتجاوز 96، وفي تلك الحالة ستقابل العلامة ‎أ+. إليك المثال التالي:

. . .
if grade >= 65:
    print("درجة النجاح:")

    if grade >= 90:
        if grade > 96:
            print("أ+")

elif grade > 93 and grade <= 96:

            print("أ")

        elif grade >= 90:
            print("أ-")
. . .

في الشيفرة أعلاه، في حال تعيين المتغير ‎grade‎ عند القيمة ‎96‎، سيقوم البرنامج بما يلي:

• التحقق مما إذا كانت الدرجة أكبر من أو تساوي 65 (صحيح)
• طباعة ‎درجة النجاح:‎
• التحقق مما إذا كانت الدرجة أكبر من أو تساوي 90 (صحيح)
• التحقق مما إذا كانت الدرجة أكبر من 96 (خطأ)
• التحقق مما إذا كانت الدرجة أكبر من 93، وأقل من أو تساوي 96 (صحيح)
• طباعة أ‎
• تجاوز التعليمات الشرطية المتشعبة وتنفيذ باقي الشيفرة

ستكون مخرجات البرنامج في حال كانت الدرجة تساوي 96 كالتالي:

درجة النجاح:
أ

تساعد تعليمات ‎if‎ المتشعبة على إضافة عدة مستويات من الشروط الفرعية إلى الشيفرة.

خلاصة

ستتحكم باستخدام التعليمات الشرطية، مثل التعليمة ‎if‎، في مسار البرنامج أي تدفق تنفيذ الشيفرة. تطلب التعليمات الشرطية من البرنامج التحقق من استيفاء شرط معين من عدمه. وإذا تم استيفاء الشرط، فستُنفّذ شيفرة معينة، وإلا فسيستمر البرنامج وينتقل إلى الأسطر التالية.

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

هذه المقالة جزء من سلسة مقالات حول تعلم البرمجة في بايثون 3.

ترجمة -وبتصرّف- للمقال How To Write Conditional Statements in Python 3 لصاحبته Lisa Tagliaferri

اقرأ أيضًا

• المقالة التالية: كيفية إنشاء حلقات تكرار while في بايثون 3
• المقالة السابقة: كيفية كتابة الوحدات في بايثون 3
• المرجع الشامل إلى تعلم لغة بايثون
• كتاب البرمجة بلغة بايثون

وحدات (modules) بايثون هي ملفات ‎.py‎ تحتوي شفرة بايثون، ويمكن التعامل مع أيّ ملف بايثون على أنه وحدة.

تتوفر بعض الوحدات في مكتبة بايثون القياسية، والتي تُثبّت تلقائيًا مع بايثون. يمكن لبعضها الآخر أن يُثبّت عبر مدير الحزم pip. بالإضافة إلى ذلك، يمكنك إنشاء وحدات بايثون خاصة بك، لأنّ الوحدات هي مجرد ملفات ‎.py‎.

سيرشدك هذا الدرس إلى كيفية كتابة وحدات بايثون لاستخدامها في ملفات البرمجة الأخرى.

كتابة الوحدات واستيرادها

كتابة الوحدات مشابه لكتابة أي ملف بايثون آخر. يمكن أن تحتوي الوحدات على تعريفات الدوال والأصناف والمتغيرات التي يمكن استخدامها بعد ذلك في برامج بايثون الأخرى.

سنشئ من بيئة البرمجة الحالية الخاصة ببايثون 3 أو بيئة البرمجة المستندة إلى الخادم ملفًّا باسم ‎hello.py‎، والذي سنتستورده لاحقًا من ملف آخر.

في البدء، سننشئ دالة تطبع العبارة مرحبا بالعالم!:

# تعريف دالة
def world():
    print("مرحبا بالعالم!")

إذا نفّذنا البرنامج في سطر الأوامر باستخدام ‎python hello.py‎، فلن يحدث شيء، لأننا لم نطلب من البرنامج فعل أي شيء.

لننشئ ملفًا ثانيًا في نفس المجلد (أي بجانب الملف السابق) باسم ‎main_program.py‎ حتى نتمكن من استيراد الوحدة التي أنشأناها للتو، ومن ثم استدعاء الدالة. يجب أن يكون هذا الملف في نفس المجلد حتى تعرف بايثون موضع الوحدة، لأنها ليست وحدة مُضمّنة.

# hello استيراد الوحدة
import hello

# استدعاء الدالة
hello.world()

نظرًا لأننا استوردنا الوحدة، نحتاج إلى استدعاء الدالة من خلال التأشير إلى اسم الوحدة بالصياغة النقطية (dot notation).

يمكننا بدلًا من ذلك استيراد دالة محدَّدة من الوحدة بالتعليمة ‎from hello import world‎، واستدعاء تلك الدالة بالشكل ‎world()‎ كما تعلمنا ذلك من الدرس السابق.

الآن، يمكننا تنفيذ البرنامج من سطر الأوامر:

python main_program.py

سنحصل على المخرجات التالية:

مرحبا بالعالم!

لنرى كيف يمكننا استخدام المتغيرات في الوحدات، دعنا نضيف تعريفًا لمتغير في الملف ‎hello.py‎:

# تعريف دالة
def world():
    print("مرحبا بالعالم!")

# تعريف المتغير
shark = "Sammy"

بعد ذلك، سنستدعي المتغير داخل الدالة ‎print()‎ في الملف ‎main_program.py‎:

# hello استيراد الوحدة
import hello

# استدعاء الدالة
hello.world()

# طباعة المتغير
print(hello.shark)

بمجرد تنفيذ البرنامج، سنحصل على المخرجات التالية:

مرحبا بالعالم!
Sammy

أخيرًا، دعنا نعرّف صنفًا في الملف ‎hello.py‎. سننشئ الصنف ‎Octopus‎، والذي يحتوي على الخاصيتين ‎name‎ و ‎color‎، إضافة إلى دالة تطبع الخاصيات عند استدعائها.

# تعريف الدالة
def world():
    print("مرحبا بالعالم!")

# تعريف المتغير
shark = "Sammy"

# تعريف الصنف
class Octopus:
    def __init__(self, name, color):
        self.color = color
        self.name = name

    def tell_me_about_the_octopus(self):
        print("This octopus is " + self.color + ".")
        print(self.name + " is the octopus's name.")

سنضيف الآن الصنفَ إلى نهاية الملف ‎main_program.py‎:

# hello استيراد الوحدة
import hello


# استدعاء الدالة
hello.world()

# طباعة المتغير
print(hello.shark)

# استدعاء الصنف
jesse = hello.Octopus("Jesse", "orange")
jesse.tell_me_about_the_octopus()

بمجرد استدعاء الصنف Octopus باستخدام ‎hello.Octopus()‎، يمكننا الوصول إلى دوال وخاصيات الصنف من فضاء الأسماء الخاص بالملف ‎main_program.py‎. يتيح لنا هذا كتابة ‎jesse.tell_me_about_the_octopus()‎ في السطر الأخير دون استدعاء ‎hello‎. يمكننا أيضًا، على سبيل المثال، استدعاء إحدى خاصيات الصنف، مثل ‎jesse.color‎، دون الرجوع إلى اسم الوحدة ‎hello‎.

سنحصل عند تنفيذ البرنامج على المخرجات التالية:

مرحبا بالعالم!
Sammy
This octopus is orange.
Jesse is the octopus's name.

من المهم أن تضع في الحسبان أنه على الرغم من أنّ الوحدات غالبًا ما تضم تعريفات، إلا أنها يمكن أيضًا أن تقدم شفرات برمجية. لتوضيح هذا، دعنا نعيد كتابة الملف ‎hello.py‎ لنجعله يقدم دالة ‎world()‎:

# تعريف دالة
def world():
    print("مرحبا بالعالم!")

# استدعاء الدالة داخل الوحدة
world()

لقد حذفنا أيضًا التعريفات الأخرى في الملف. الآن، في الملف ‎main_program.py‎، سنحذف كل الأسطر باستثناء عبارة الاستيراد:

# hello استيراد الوحدة
import hello

عند تنفيذ ‎main_program.py‎، سنحصل على المخرجات التالية:

مرحبا بالعالم!

هذا لأنّ الوحدة ‎hello‎ قدمت الدالة ‎world()‎، والتي مُرِّرت بعد ذلك إلى ‎main_program.py‎ لتُنفّذ مع السكربت ‎main_program.py‎.

الوحدة هي ملف بايثون مؤلف من تعريفات و شيفرات برمجية يمكن الاستفادة منها في ملفات بايثون الأخرى.

الوصول إلى الوحدات من مجلد آخر

قد تكون الوحدات مفيدة لأكثر من مشروع واحد، وفي هذه الحالة، لن يكون من الحكمة الاحتفاظ بالوحدة في مجلد مرتبط بمشروع خاص.

إذا أردت استخدام وحدة من مجلد آخر غير المجلد الذي يحوي البرنامج الرئيسي، فأمامك عدة خيارات سنسردها فيما يلي.

التعرف تلقائيًا على مسار الوحدة

أحد الخيارات هو استدعاء مسار الوحدة من الملفات البرمجية التي تستخدم تلك الوحدة. يُعد هذا حلًّا مؤقتًا يمكن استخدامه أثناء عملية التطوير، لأنه لا يجعل الوحدة متاحة على مستوى النظام بأكمله.

لإلحاق مسار وحدة بملف برمجي آخر، ستبدأ باستيراد الوحدة ‎sys‎، إلى جانب الوحدات الأخرى التي ترغب في استخدامها في ملف البرنامج الرئيسي.

تعد الوحدة ‎sys‎ جزءًا من مكتبة بايثون القياسية، وتوفر معاملات ودوال نظامية يمكنك استخدامها في برنامجك لتعيين مسار الوحدة التي ترغب في تقديمها.

على سبيل المثال، لنقل أننا نقلنا الملف ‎hello.py‎ إلى المسار ‎/usr/sammy/‎، بينما يوجد الملف ‎main_program.py‎ في مجلد آخر.

في الملف ‎main_program.py‎، ما يزال بإمكاننا استيراد الوحدة ‎hello‎ عن طريق استيراد الوحدة ‎sys‎، ثم إضافة المسار ‎/usr/sammy/‎ إلى المسارات التي يبحث بايثون فيها عن الملفات.

import sys
sys.path.append('/usr/sammy/')

import hello
...

إن عيّنت مسار الملف ‎hello.py‎ بشكل صحيح، فسيكون بمقدورك تنفيذ الملف ‎main_program.py‎ دون أيّ أخطاء، وستحصل على نفس المخرجات التي حصلنا عليها أعلاه عندما كان ‎hello.py‎ في نفس المجلد.

إضافة الوحدة إلى مسار بايثون

الخيار الثاني هو إضافة الوحدة إلى المسار الذي يبحث فيه بايثون عن الوحدات والحزم. هذا حل أفضل وأدوم، لأنه يجعل الوحدة متاحة على نطاق البيئة، أو على مستوى النظام.

لمعرفة المسار الذي يبحث فيه بايثون، شغِّل مترجم (interpreter) بايثون من بيئة البرمجة خاصتك:

python

بعد ذلك، استورد الوحدة ‎sys‎:

import sys

ثم اطلب من بايثون طباعة مسار النظام:

print(sys.path)

ستحصل على بعض المخرجات، وسيُطبع مسار نظام واحد على الأقل. إذا كنت تعمل في بيئة برمجة، فقد تتلقى العديد منها. سيكون عليك البحث عن المسارات الموجودة في البيئة التي تستخدمها حاليًا، ولكن قد ترغب أيضًا في إضافة الوحدة إلى مسار النظام الرئيسي لبايثون. النتيجة ستكون مشابهة لما يلي:

'/usr/sammy/my_env/lib/python3.5/site-packages'

يمكنك الآن نقل الملف ‎hello.py‎ إلى هذا المجلد. بعد ذلك، يمكنك استيراد الوحدة ‎hello‎ كالمعتاد:

import hello
...

عند تنفيذ البرنامج، يُفترض ألا يحدث أيّ خطأ.

يضمن لك تعديل مسار الوحدة إمكانية الوصول إليها مهما كان المجلد الذي تعمل فيه. هذا مفيد خاصة في حال كنت تعمل على عدة مشاريع تشير إلى الوحدة نفسها.

خلاصة

إنّ كتابة وحدات بايثون لا يختلف عن كتابة أيّ ملف بايثون آخر. غطينا في هذه المقالة كيفية كتابة التعاريف في الوحدات، وكيفية استخدامها في ملف بايثون آخر، وعرضنا بعض الخيارات حول المواضِع التي يمكن أن تحفظ فيها الوحدة لتجعلها متاحة.

يمكنك تعلم المزيد حول تثبيت الوحدات واستيرادها من الدرس السابق: [كيفية استيراد الوحدات في بايثون 3]().

هذه المقالة جزء من سلسة مقالات حول تعلم البرمجة في بايثون 3.

ترجمة -وبتصرّف- للمقال How To Write Modules in Python 3 لصاحبته Lisa Tagliaferri

اقرأ أيضًا

• المقالة التالية: كيفية كتابة العبارات الشرطية في بايثون 3
• المقالة السابقة: كيفية استيراد الوحدات في بايثون 3
• المرجع الشامل إلى تعلم لغة بايثون
• كتاب البرمجة بلغة بايثون

توفر لغة بايثون مجموعة متنوعة من الدوال المضمّنة مثل:

• print()‎‎: تطبع التعابير المُمرَّرة إليها في مجرى الخرج
• abs()‎‎: تُعيد القيمة المطلقة للعدد
• int()‎‎: تحوِّل نوع بيانات إلى عدد صحيح
• len()‎‎: تُعيد طول تسلسل أو مجموعة

هذه الدوال المضمّنة وغيرها مفيدة، لكنها محدودة، لهذا يستخدم المطورون الوحدات (modules) لتطوير برامج أكثر تعقيدًا.

الوحدات (Modules) هي ملفات بايثون ذات امتداد ‎.py، والتي تحوي شيفرات بايثون. يمكن التعامل مع أيّ ملف بايثون على أنه وحدة. مثلًا، إن كان هناك ملف بايثون يسمى hello.py، فسيكون اسم الوحدة المقابلة له hello، والذي يمكن استيراده في ملفات بايثون الأخرى، أو استخدامه في مترجم (interpreter) سطر أوامر بايثون. ستتعلم في المقالة التالية كيفية إنشاء الوحدات.

يمكن للوحدات أن تعرِّف دوالًا وأصنافًا ومتغيرات يمكن الرجوع إليها من ملفات بايثون الأخرى، أو من مترجم سطر أوامر بايثون.

في بايثون، يمكنك الوصول إلى الوحدات باستخدام العبارة import. عند فعل ذلك، ستُنفَّذ شيفرة الوحدة، مع الاحتفاظ بنطاقات (scopes) التعريفات حتى تكون متاحة في ملفك الحالي.

عندما تستورد بايثون وحدةً باسم hello على سبيل المثال، فسيبحث المترجم أولًا عن وحدة مضمّنة باسم hello. فإن لم يجد، فسيبحث عن ملف يسمى hello.py في قائمة من المجلدات يحددها المتغير sys.path.

سيرشدك هذا الدرس إلى كيفية البحث عن الوحدات وتثبيتها، واستيرادها، وإعادة تسميتها (aliasing).

تثبيت الوحدات

هناك عدد من الوحدات المضمنة في مكتبة بايثون القياسية التي تحتوي على العديد من الوحدات التي توفر الكثير من وظائف النظام، أو توفر حلولًا قياسية. مكتبة بايثون القياسية تأتي مع كل توزيعات بايثون.

للتحقق من أنّ وحدات بايثون جاهزة للعمل، ادخل إلى بيئة برمجة بايثون 3 المحلية، أو بيئة البرمجة المستندة إلى الخادم، وشغّل مترجم بايثون في سطر الأوامر على النحو التالي:

(my_env) sammy@ubuntu:~/environment$ python

من داخل المترجم، يمكنك تنفيذ العبارة import مع اسم الوحدة للتأكد من أنّها جاهزة:

import math

لمّا كانت math وحدة مضمّنة، فينبغي أن يُكمل المترجم المهمة دون أي مشاكل، ثم يعود إلى المحث (prompt). هذا يعني أنك لست بحاجة إلى فعل أيّ شيء للبدء في استخدام الوحدة math.

لننفِّذ الآن العبارة import مع وحدة قد لا تكون مُثبّتة عندك، مثل matplotlib، وهي مكتبة للرسم ثنائي الأبعاد:

import matplotlib

إذا لم تكن matplotlib مثبتة، فستتلقّى خطأً مثل هذا:

ImportError: No module named 'matplotlib'

يمكنك إيقاف مترجم بايثون بالضغط على CTRL + D، ثم تثبيت الوحدة matplotlib عبر pip بتنفيذ الأمر التالي:

(my_env) sammy@ubuntu:~/environment$ pip install matplotlib

بمجرد تثبيتها، يمكنك استيراد matplotlib من مترجم بايثون باستخدام import matplotlib، ولن يحدث أيّ خطأ.

استيراد الوحدات

للاستفادة من الدوال الموجودة في الوحدة، ستحتاج إلى استيراد الوحدة عبر التعليمة import.

تتألف التعليمة import من الكلمة المفتاحية import معقوبة باسم الوحدة.

يُصرَّح عن عملية استيراد الوحدات في أعلى ملفات بايثون، قبل الأسطر التوجيهية (shebang lines أي الأسطر التي تبدأ بـ ‎#!‎)، أو التعليقات العامة.

لذلك، سنستورد في ملف برنامج بايثون my_rand_int.py الوحدة random لتوليد أعداد عشوائية على النحو التالي:

import random

عندما نستورد وحدة، فإننا نجعلها متاحة في برنامجنا الحالي كفضاء أسماء (namespace) منفصل. هذا يعني أنه سيتعيّن علينا الرجوع إلى الدالة باستخدام الصياغة النقطية (dot notation) على النحو التالي [module].[function].

عمليًا، باستخدام مثال الوحدة random، ستبدو الشفرة كما يلي:

• random.randint()‎‎‎: تستدعي الدالة لإعادة عدد صحيح عشوائي، أو
• random.randrange()‎‎: تستدعي الدالة لإعادة عنصر عشوائي من نطاق محدد.

دعنا ننشئ حلقة for لتوضيح كيفية استدعاء دالة من الوحدة random ضمن البرنامج my_rand_int.py:

import random

for i in range(10):
    print(random.randint(1, 25))

يستورد هذا البرنامج الصغير الوحدة random في السطر الأول، ثم ينتقل إلى الحلقة for التي ستمر على 10 عناصر. داخل الحلقة، سيطبع البرنامج عددًا صحيحًا عشوائيًا من المجال 1 إلى 25 (مشمول). يُمرّّر العددان الصحيحان 1 و 25 إلى random.randint()‎‎ كمعاملين.

عند تنفيذ البرنامج باستخدام الأمرpython my_rand_int.py، ستظهر 10 أعداد صحيحة عشوائية في المخرجات. نظرًا لأنّ هذه العناصر عشوائية، فستحصل على الأرجح على أعداد مختلفة في كل مرة تنفّذ فيها البرنامج، لكنها عمومًا ستبدو كما يلي:

6
9
1
14
3
22
10
1
15
9

الأعداد الصحيحة كلها محصورة بين 1 و 25.

إذا كنت ترغب في استخدام دوال من أكثر من وحدة، يمكنك ذلك عن طريق إضافة عدة تعليمات استيراد:

import random
import math

قد تصادف برامج تستورد عدة وحدات مفصولة بفواصل - مثل import random, math - ولكنّ هذا لا يتوافق مع دليل التنسيق PEP 8.

للاستفادة من الوحدة الإضافية، يمكننا إضافة الثابت pi من الوحدة math إلى برنامجنا، وتقليل عدد الأعداد الصحيحة العشوائية المطبوعة:

import random
import math


for i in range(5):
    print(random.randint(1, 25))

print(math.pi)

الآن، عند تنفيذ البرنامج، سنحصل على مخرجات على الشكل التالي، مع تقريب للعدد pi في السطر الأخير:

18
10
7
13
10
3.141592653589793

تتيح لك التعليمة import استيراد وحدة واحدة أو أكثر إلى برامجك، وهذ يمكّنك من الاستفادة مما تحويها تلك الوحدات.

استخدام الصياغة from ... import

للإشارة إلى عناصر من وحدة مستوردة ضمن فضاء الأسماء، يمكنك استخدام التعليمة from ... import. عندما تستورد الوحدات بهذه الطريقة، سيكون بمقدورك الرجوع إلى الدوال بأسمائها فقط، بدلًا من استخدام الصياغة النقطية.

في هذه الصياغة، يمكنك تحديد التعريفات التي تود الإشارة إليها مباشرة.

في بعض البرامج، قد ترى العبارة * from ... import، إذ تشير العلامة * إلى جميع العناصر الموجودة في الوحدة، ولكنّ هذه الصياغة غير معتمدة في PEP 8.

سنحاول في البداية استيراد دالة واحدة من الوحدة random، وهي randint()‎‎:

from random import randint

هنا، نستدعي أولًا الكلمة المفتاحية from، ثم random. بعد ذلك، نستخدم الكلمة المفتاحية import، ونستدعي الدالة المحددة التي نودّ استخدامها.

الآن، عندما نرغب في استخدام هذه الدالة في برنامجنا، لن نستدعي الدالة وفق الصياغة النقطية، random.randint()‎‎، ولكن سنستدعيها باسمها مباشرةً، أي randint()‎‎:

from random import randint


for i in range(10):
    print(randint(1, 25))

عند تنفيذ البرنامج، ستتلقى مخرجات مشابهة لما تلقيته مسبقًا.

يتيح لنا استخدام from ... import الرجوع إلى العناصر المعرّفة في الوحدة من فضاء الأسماء الخاص ببرنامجنا، مما يتيح لنا تجنب استخدام الصياغة النقطية الطويلة.

الأسماء المستعارة في الوحدات

يمكن تعديل أسماء الوحدات ودوالها داخل بايثون باستخدام الكلمة المفتاحية as.

قد ترغب في تغيير اسم ما لأنك تستخدمه سلفًا في برنامجك، أو أنه مستخدم في وحدة أخرى مستوردة، أو قد ترغب في اختصار اسم طويل تستخدمه كثيرًا. يمكنك ذلك عبر الصياغة التالية:

import [module] as [another_name]

لنعدّل اسم الوحدة math في ملف البرنامج my_math.py. سنغيّر اسم الوحدة math إلى m من أجل اختصاره. سيبدو برنامجنا المعدل كالتالي:

import math as m


print(m.pi)
print(m.e)

سنشير داخل البرنامج إلى الثابت pi بالتعبير m.pi، بدلًا من math.pi.

يشيع في بعض الوحدات استخدام أسماء مستعارة (aliases) محدَّدة. فمثلًا، يدعو التوثيق الرسمي للوحدة matplotlib.pyplot إلى استخدام الاسم المستعار plt:

import matplotlib.pyplot as plt

يسمح هذا للمبرمجين بإلحاق الكلمة القصيرة plt بأي دالة متاحة داخل الوحدة، كما هو الحال في plt.show()‎‎.

خلاصة

يسمح مفهوم الوحدات باستدعاء دوال غير مضمّنة في بايثون. فبعض الوحدات مُثبّتة كجزء من بايثون، وبعضها سنثبّتها عبر pip.

يتيح لنا استخدام الوحدات توسيع برامجنا وتقويتها، لأنها تضع تحت تصرّفنا شفرات جاهزة للاستخدام. يمكننا أيضًا إنشاء وحدات خاصة بنا، لنستخدمها نحن، أو المبرمجون الآخرون وهذا ما سنتعرف عليه في المقال التالي.

هذه المقالة جزء من سلسة مقالات حول تعلم البرمجة في بايثون 3.

ترجمة -وبتصرّف- للمقال How To Import Modules in Python 3 لصاحبته Lisa Tagliaferri.

اقرأ أيضًا

• المقالة التالية: كيفية كتابة الوحدات في بايثون 3
• المقالة السابقة: فهم القواميس في بايثون 3
• المرجع الشامل إلى تعلم لغة بايثون
• كتاب البرمجة بلغة بايثون

القاموس هو نوع مُضمَّن في بايثون. تربط القواميس مفاتيح بقيم على هيئة أزواج، وهذه الأزواج مفيدة لتخزين البيانات في بايثون.

تستخدم القواميس عادةً لتخزين البيانات المترابطة، مثل المعلومات المرتبطة برقم تعريف، أو ملفات تعريف المستخدم، وتُنشأ باستخدام الأقواس المعقوصة {}.

تبدو القواميس على الشكل التالي:

sammy = {'username': 'sammy-shark', 'online': True, 'followers': 987}

بالإضافة إلى القوسين المعقوصين، لاحظ وجود النقطتين الرأسيتين (:) في القاموس. الكلمات الموجودة على يسار النقطتين الرأسيتين هي المفاتيح التي قد تكون أيَّ نوع بيانات غير قابل للتغيير. المفاتيح في القاموس أعلاه هي:

• username
• online *followers

المفاتيح في المثال أعلاه عبارة عن سلاسل نصية.

تمثِّل الكلمات الموجودة على يمين النقطتين «القيم». يمكن أن تتألف القيم من أي نوع من البيانات. القيم في القاموس أعلاه هي:

• sammy-shark
• True *987

قيم القاموس أعلاه هي إمَّا سلاسل نصية أو قيم منطقية أو أعداد صحيحة.

سنطبع الآن القاموس sammy:

print(sammy)   # {'username': 'sammy-shark', 'followers': 987, 'online': True}

نلاحظ بالنظر إلى المخرجات تغير ترتيب الأزواج قيمة-مفتاح (key-value). في بايثون 3.5 وما قبله، إذ القواميس غير مرتبة. لكن ابتداءً من بايثون 3.6، صارت القواميس مرتبةً. بغض النظر عما إذا كان القاموس مرتبًا أم لا، ستظل الأزواج قيمة-مفتاح كما هي، وهذا سيمكّنك من الوصول إلى البيانات بناء على ترابطاتها.

الوصول إلى عناصر القاموس

يمكننا الوصول إلى قيم محدَّدة في القاموس بالرجوع إلى المفاتيح المرتبطة بها ويمكن أيضًا الاستعانة ببعض التوابع الجاهزة للوصول إلى القيم أو المفاتيح أو كليهما.

الوصول إلى عناصر القاموس باستخدام المفاتيح

إذا أردنا الحصول على اسم المستخدم في Sammy، فيمكننا ذلك عن طريق استدعاء sammy['username']‎. هذا مثال على ذلك:

print(sammy['username'])    #  sammy-shark

تتصرف القواميس كقواعد البيانات، فهي بدلًا من فهرسة العناصر بأعداد صحيحة، كما هو الحال في القوائم، فإنها تُفهرس العناصر (أو قيم القاموس) بمفاتيح، ويمكنك عبر تلك المفاتيح الحصول على القيم المقابلة لها.

باستدعاء المفتاح username، سنحصل على القيمة المرتبطة به، وهي sammy-shark.

وبالمِثل، يمكن استدعاء القيم الأخرى في القاموس sammy باستخدام نفس الصياغة:

sammy['followers']  # 987

sammy['online']      # True

استخدام التوابع للوصول إلى العناصر

بالإضافة إلى استخدام المفاتيح للوصول إلى القيم، يمكننا أيضًا استخدام بعض التوابع المُضمّنة، مثل:

• dict.keys()‎‎: الحصول على المفاتيح
• dict.values()‎: الحصول على القيم
• dict.items()‎: الحصول على العناصر على هيئة قائمة من أزواج (key, value)

لإعادة المفاتيح، نستخدم التابع dict.keys()‎، كما يوضح المثال التالي:

print(sammy.keys())   #  dict_keys(['followers', 'username', 'online'])

تلقينا في المخرجات كائنَ عرض تكراري (iterable view object) من الصنف dict_keys يحوي المفاتيح ثم طُبِعت المفاتيح على هيئة قائمة.

يمكن استخدام هذا التابع للاستعلام من القواميس. على سبيل المثال، يمكننا البحث عن المفاتيح المشتركة بين قاموسين:

sammy = {'username': 'sammy-shark', 'online': True, 'followers': 987}
jesse = {'username': 'JOctopus', 'online': False, 'points': 723}

for common_key in sammy.keys() & jesse.keys():
    print(sammy[common_key], jesse[common_key])

يحوي القاموسان sammy و jesse معلومات تعريف المستخدم. كما أنّ لهما مفاتيح مختلفة، لأنّ لدى Sammy ملف تعريف اجتماعي يضم مفتاحًا followers يمثل المتابعين على الشبكة الاجتماعية، أما Jesse فلها ملف تعريف للألعاب يضم مفتاحًا points يمثل النقاط. كلا القاموسين يشتركان في المفتاحين username و online، ويمكن العثور عليهما عند تنفيذ هذا البُريمج:

# المخرجات
sammy-shark JOctopus
True False

يمكننا بالتأكيد تحسين البرنامج لتسهيل قراءة المخرجات، ولكنّ الغرض هنا هو توضيح إمكانية استخدام dict.keys()‎ لرصد المفاتيح المشتركة بين عدة قواميس. هذا مفيد بشكل خاص عند العمل على القواميس الكبيرة.

وبالمثل، يمكننا استخدام التابع dict.values()‎ للاستعلام عن القيم الموجودة في القاموس sammy على النحو التالي:

sammy = {'username': 'sammy-shark', 'online': True, 'followers': 987}

print(sammy.values())   #  dict_values([True, 'sammy-shark', 987])

يُعيد كلا التابعان values()‎ و keys()‎‎ قوائم غير مرتبة تضم مفاتيح وقيم القاموس sammy على هيئة كائِني عرضٍ من الصنف dict_values و dict_keys على التوالي.

إن أردت الحصول على الأزواج الموجودة في القاموس، فاستخدم التابع items()‎:

print(sammy.items())  

المخرجات ستكون:

dict_items([('online', True), ('username', 'sammy-shark'), ('followers', 987)])

النتيجة المعادة ستكون على هيئة قائمة مكونة من أزواج (key, value) من الصنف dict_items.

يمكننا التكرار (iterate) على القائمة المُعادة باستخدام الحلقة for. على سبيل المثال، يمكننا طباعة جميع مفاتيح وقيم القاموس المحدد، ثم جعلها أكثر مقروئية عبر إضافة سلسلة نصية توضيحية:

for key, value in sammy.items():
    print(key, 'is the key for the value', value)

وسينتج لنا:

online is the key for the value True
followers is the key for the value 987
username is the key for the value sammy-shark

كرَّرت الحلقة for على العناصر الموجودة في القاموس sammy، وطبعت المفاتيح والقيم سطرًا سطرًا، مع إضافة معلومات توضيحية.

تعديل القواميس

القواميس هي هياكل بيانات قابلة للتغيير (mutable)، أي يمكن تعديلها. في هذا القسم، سنتعلم كيفية إضافة عناصر إلى قاموس، وكيفية حذفها.

إضافة وتغيير عناصر القاموس

يمكنك إضافة أزواج قيمة-مفتاح إلى قاموس دون استخدام توابع أو دوال باستخدام الصياغة التالية:

dict[key] = value

في المثال التالي، سنضيف زوجًا مفتاح-قيمة إلى قاموس يُسمى usernames:

usernames = {'Sammy': 'sammy-shark', 'Jamie': 'mantisshrimp54'}

usernames['Drew'] = 'squidly'

print(usernames)    #  {'Drew': 'squidly', 'Sammy': 'sammy-shark', 'Jamie': 'mantisshrimp54'}

لاحظ أنّ القاموس قد تم تحديثه بالزوج 'Drew': 'squidly'. نظرًا لأنّ القواميس غير مرتبة، فيمكن أن يظهر الزوج المُضاف في أيّ مكان في مخرجات القاموس. إذا استخدمنا القاموس usernames لاحقًا، فسيظهر فيه الزوج المضاف حديثًا.

يمكن استخدام هذه الصياغة لتعديل القيمة المرتبطة بمفتاح معيّن. في هذه الحالة، سنشير إلى مفتاح موجود سلفًا، ونمرر قيمة مختلفة إليه.

سنعرِّف في المثال التالي قاموسًا باسم drew يمثِّل البيانات الخاصة بأحد المستخدمين على بعض الشبكات الاجتماعية. حصل هذا المستخدم على عدد من المتابعين الإضافيين اليوم، لذلك سنحدّث القيمة المرتبطة بالمفتاح followers ثم نستخدم التابع print()‎ للتحقق من أنّ القاموس قد عُدِّل.

drew = {'username': 'squidly', 'online': True, 'followers': 305}

drew['followers'] = 342

print(drew)    #  {'username': 'squidly', 'followers': 342, 'online': True}

في المخرجات نرى أنّ عدد المتابعين قد قفز من 305 إلى 342.

يمكننا استخدام هذه الطريقة لإضافة أزواج قيمة-مفتاح إلى القواميس عبر مدخلات المستخدم. سنكتب بريمجًا سريعًا، usernames.py، يعمل من سطر الأوامر ويسمح للمستخدم بإضافة الأسماء وأسماء المستخدمين المرتبطة بها:

# تعريف القاموس الأصلي
usernames = {'Sammy': 'sammy-shark', 'Jamie': 'mantisshrimp54'}
# while إعداد الحلقة التكرارية 
while True:
    # اطلب من المستخدم إدخال اسم
    print('Enter a name:')

    # name تعيين المدخلات إلى المتغير  
   name = input()

    # تحقق مما إذا كان الاسم موجودًا في القاموس ثم اطبع الرد
    if name in usernames:
         print(usernames[name] + ' is the username of ' + name)

    # إذا لم يكن الاسم في القاموس 
    else:

        # اطبع الرد        
        print('I don\'t have ' + name + '\'s username, what is it?')

        # خذ اسم مستخدم جديد لربطه بذلك الاسم 
        username = input()

        # name عين قيمة اسم المستخدم إلى المفتاح 
        usernames[name] = username

        # اطبع ردًا يبيّن أنّ البيانات قد حُدّثت
        print('Data updated.')

سننفِّذ البرنامج من سطر الأوامر:

python usernames.py

عندما ننفّذ البرنامج، سنحصل على مخرجات مشابهة لما يلي:

Enter a name:
Sammy
sammy-shark is the username of Sammy
Enter a name:
Jesse
I don't have Jesse's username, what is it?
JOctopus
Data updated.
Enter a name:

عند الانتهاء من اختبار البرنامج، اضغط على CTRL + C للخروج من البرنامج. يمكنك تخصيص حرف لإنهاء البرنامج (مثل الحرف q)، وجعل البرنامج يُنصت له عبر العبارات الشرطية.

يوضح هذا المثال كيف يمكنك تعديل القواميس بشكل تفاعلي. في هذا البرنامج، بمجرد خروجك باستخدام CTRL + C، ستفقد جميع بياناتك، إلا إن خزّنت البيانات في ملف.

يمكننا أيضًا إضافة عناصر إلى القواميس وتعديلها باستخدام التابع dict.update()‎. هذا التابع مختلف عن التابع append()‎ الذي يُستخدم مع القوائم.

سنضيف المفتاح followers في القاموس jesse أدناه، ونَمنحه قيمة عددية صحيحة بواسطة التابع jesse.update()‎. بعد ذلك، سنطبع القاموس المُحدّث.

jesse = {'username': 'JOctopus', 'online': False, 'points': 723}

jesse.update({'followers': 481})

print(jesse)    #  {'followers': 481, 'username': 'JOctopus', 'points': 723, 'online': False}

من المخرجات، نتبيّن أننا نجحنا في إضافة الزوج ‎followers: 481 إلى القاموس jesse.

يمكننا أيضًا استخدام التابع dict.update()‎ لتعديل زوج قيمة-مفتاح موجود سلفًا عن طريق استبدال قيمة مفتاح معيَّن.

سنغيِّر القيمة المرتبطة بالمفتاح online في القاموس Sammy من True إلى False:

sammy = {'username': 'sammy-shark', 'online': True, 'followers': 987}

sammy.update({'online': False})

print(sammy)   #  {'username': 'sammy-shark', 'followers': 987, 'online': False}

يغيّر السطر sammy.update({'online': False})‎ القيمة المرتبطة بالمفتاح 'online' من True إلى False. عند استدعاء التابع print()‎‎ على القاموس، يمكنك أن ترى في المخرجات أنّ التحديث قد تمّ.

لإضافة عناصر إلى القواميس أو تعديل القيم، يمكن إمّا استخدام الصياغة dict[key] = value، أو التابع dict.update()‎.

حذف عناصر من القاموس

كما يمكنك إضافة أزواج قيمة-مفتاح إلى القاموس، أو تغيير قيمه، يمكنك أيضًا حذف العناصر الموجودة في القاموس.

لتزيل زوج قيمة-مفتاح من القاموس، استخدم الصياغة التالية:

del dict[key]

لنأخذ القاموس jesse الذي يمثل أحد المستخدمين، ولنفترض أنّ jesse لم تعد تستخدم المنصة لأجل ممارسة الألعاب، لذلك سنزيل العنصر المرتبط بالمفتاح points. بعد ذلك، سنطبع القاموس لتأكيد حذف العنصر:

jesse = {'username': 'JOctopus', 'online': False, 'points': 723, 'followers': 481}

del jesse['points']

print(jesse)   #  {'online': False, 'username': 'JOctopus', 'followers': 481}

يزيل السطر del jesse ['points']‎ الزوج 'points': 723 من القاموس jesse.

إذا أردت محو جميع عناصر القاموس، فيمكنك ذلك باستخدام التابع dict.clear()‎. سيَبقى هذا القاموس في الذاكرة، وهذا مفيد في حال احتجنا إلى استخدامه لاحقًا في البرنامج، بيْد أنه سيُفرِّغ جميع العناصر من القاموس.

دعنا نزيل كل عناصر القاموس jesse:

jesse = {'username': 'JOctopus', 'online': False, 'points': 723, 'followers': 481}

jesse.clear()

print(jesse)    #  {}

تُظهِر المخرجات أنّ القاموسًا صار فارغًا الآن.

إذا لم تعد بحاجة إلى القاموس، فاستخدم del للتخلص منه بالكامل:

del jesse

print(jesse)

إذا نفّذت الأمر print()‎ بعد حذف القاموس jesse، سوف تتلقى الخطأ التالي:

NameError: name 'jesse' is not defined

خلاصة

ألقينا في هذه المقالة نظرة على القواميس في بايثون. تتألف القواميس من أزواج قيمة-مفتاح، وتوفر حلًّا ممتازًا لتخزين البيانات دون الحاجة إلى فهرستها. يتيح لنا ذلك استرداد القيم بناءً على معانيها وعلاقتها بأنواع البيانات الأخرى.

يمكنك تعلم المزيد عن أنواع البيانات الأخرى من المقالة التالية: "فهم أنواع البيانات في بايثون 3".

هذه المقالة جزء من سلسة مقالات حول تعلم البرمجة في بايثون 3.

ترجمة -وبتصرّف- للمقال Understanding Dictionaries in Python 3 لصاحبته Lisa Tagliaferri

اقرأ أيضًا

• المقالة التالية: كيفية استيراد الوحدات في بايثون 3
• المقالة السابقة: فهم نوع البيانات Tuples في بايثون 3
• المرجع الشامل إلى تعلم لغة بايثون
• كتاب البرمجة بلغة بايثون

يبدو نوع البيانات tuple في بايثون كما يلي:

coral = ('blue coral', 'staghorn coral', 'pillar coral', 'elkhorn coral')

tuple (صف وتُجمَع إلى صفوف) هي بنية بيانات تُمثِّل سلسلة مرتبة من العناصر غير القابلة للتبديل، وبالتالي لا يمكن تعديل القيم الموجودة فيها.
يستعمل نوع البيانات tuple لتجميع البيانات، فكل عنصر أو قيمة داخل tuple تُشكِّل جزءًا منه.
توضع القيم داخل نوع البيانات tuple بين قوسين ( ) ويُفصَل بينها بفاصلة ,، وتبدو القيم الفارغة كما يلي coral = ()‎، لكن إذا احتوى نوع البيانات tuple على قيم –حتى لو كانت قيمةً واحدةً فقط– فيجب وضع فاصلة فيه مثل coral = ('blue coral',).
إذا استخدمنا الدالة print()‎ على tuple، فسنحصل على الناتج الآتي الذي يُبيّن أنَّ القيمة الناتجة ستوضع بين قوسين:

print(coral)
('blue coral', 'staghorn coral', 'pillar coral', 'elkhorn coral')

عند التفكير بنوع tuple وغيره من بنى البيانات التي تُعبَر من أنوع «المجموعات» (collections)، فمن المفيد أن تضع ببالك مختلف المجموعات الموجودة في حاسوبك: تشكيلة الملفات الموجودة عندك، وقوائم التشغيل للموسيقى، والمفضلة الموجودة في متصفحك، ورسائل بريدك الإلكتروني، ومجموعة مقاطع الفيديو التي تستطيع الوصول إليها من التلفاز، والكثير.
نوع tuple شبيه بالقوائم (lists)، لكن القيم الموجودة فيه لا يمكن تعديلها، وبسبب ذلك، فأنت تخبر الآخرين أنَّك لا تريد إجراء أيّة تعديلات على هذه السلسلة من القيم عندما تستعمل tuple في شيفرتك. إضافةً إلى ما سبق، ولعدم القدرة على تعديل القيم، فسيكون أداء برنامجك أفضل، حيث ستُنفَّذ الشيفرة بشكل أسرع إذا استعملتَ tuple بدلًا من القوائم (lists).

فهرسة نوع البيانات tuple

يمكن الوصول إلى كل عنصر من عناصر tuple بمفرده لأنَّه سلسلة مرتبة من العناصر، وذلك عبر الفهرسة.
وكل عنصر يرتبط برقم فهرس، الذي هو عدد صحيح يبدأ من الفهرس 0.
لمثال coral السابق، ستبدو الفهارس والقيم المرتبطة بها كالآتي:

العنصر الأول الذي يُمثِّل السلسلة النصية 'blue coral' تبدأ بالفهرس 0، وتنتهي القائمة بالفهرس رقم 3 المرتبط بالقيمة 'elkhorn coral'.
ولأن كل عنصر من عناصر tuple له رقم فهرس مرتبط به، فسنتمكن من الوصول إلى عناصره فرادى.
يمكننا الآن الوصول إلى عنصر معيّن في tuple عبر استخدام رقم الفهرس المرتبط به.

print(coral[2])
pillar coral

تتراوح قيم الفهارس في المتغير coral من 0 إلى 3 كما هو ظاهر في الجدول السابق، لذا يمكننا استدعاء العناصر الموجودة فيه فرادى كما يلي:

coral[0]
coral[1]
coral[2]
coral[3]

إذا حاولنا استدعاء المتغير coral مع رقم فهرس أكبر من 3، فستظهر رسالة خطأ تشير إلى أنَّ الفهرس خارج المجال:

print(coral[22])
IndexError: tuple index out of range

إضافةً إلى أرقام الفهارس الموجبة، يمكننا أيضًا الوصول إلى الفهارس باستخدام رقم فهرس سالب، وذلك بالعد بدءًا من نهاية قائمة العناصر وسيرتبط آخر عنصر بالفهرس ‎-1، وهذا مفيدٌ جدًا إذا كان لديك متغير من النوع tuple وكان يحتوي عناصر كثيرة وأردتَ الوصول إلى أحد عناصره انطلاقًا من النهاية.
ففي مثالنا السابق عن coral، إذا أردنا استخدام الفهارس السالبة فالناتج كالآتي:

إذا أردنا طباعة العنصر 'blue coral' باستخدام الفهارس السالبة، فستبدو التعليمة كما يلي:

print(coral[-4])
blue coral

يمكننا إضافة العناصر النصية الموجودة في tuple إلى السلاسل النصية الأخرى باستخدام المعامل +:

print('This reef is made up of ' + coral[1])
This reef is made up of staghorn coral

استطعنا في المثال السابق إضافة عنصر موجود في الفهرس 1 مع السلسلة النصية 'This reef is made up of '، ويمكننا أيضًا استخدام المعامل + لإضافة بنيتَي tuple معًا.
الخلاصة: يمكننا الوصول إلى كل عنصر من عناصر tuple على حدة باستخدام أرقام الفهارس (الموجبة أو السالبة) المرتبطة بها.

تقطيع قيم tuple

يمكننا استخدام الفهارس للوصول إلى عدِّة عناصر من tuple، أما التقطيع فيسمح لنا بالوصول إلى عدِّة قيم عبر إنشاء مجال من أرقام الفهارس المفصولة بنقطتين رأسيتين [x:y].
لنقل أننا نريد عرض العناصر الموجودة في وسط المتغير coral، يمكننا فعل ذلك بإنشاء قطعة جديدة:

print(coral[1:3])
('staghorn coral', 'pillar coral')

عند إنشاء قطعة جديدة –كما في المثال السابق– فيمثِّل أوّل رقم مكان بدأ القطعة (متضمنةً هذا الفهرس)، ورقم الفهرس الثاني هو مكان نهاية القطعة (دون تضمين هذا الفهرس بالقطعة)، وهذا هو السبب وراء عرض المثال السابق للقيم المرتبطة بالعناصر الموجودة في الفهرسين 1 و 2.
إذا أردتَ تضمين إحدى نهايتَي القائمة، فيمكنك حذف أحد الأرقام في التعبير tuple[x:y]، فمثلًا، لنقل أننا نريد عرض أوّل ثلاثة عناصر من coral، والتي هي 'blue coral' و 'staghorn coral' و 'pillar coral'، فيمكننا فعل ذلك كالآتي:

print(coral[:3])
('blue coral', 'staghorn coral', 'pillar coral')

المثال السابق عرض العناصر من بداية القائمة وتوقف قبل العنصر ذي الفهرس 3.
لتضمين كل العناصر الموجودة في نهاية tuple، فيمكننا عكس التعبير السابق:

print(coral[1:])
('staghorn coral', 'pillar coral', 'elkhorn coral')

يمكننا استخدام الفهارس السالبة أيضًا عند التقطيع، كما فعلنا مع أرقام الفهارس الموجبة:

print(coral[-3:-1])
print(coral[-2:])
('staghorn coral', 'pillar coral')
('pillar coral', 'elkhorn coral')

هنالك معاملٌ إضافيٌ يمكننا استعماله ويسمى «الخطوة»، ويُشير إلى عدد العناصر التي يجب تجاوزها بعد الحصول على أوّل عنصر من القائمة.
حذفنا في جميع أمثلتنا السابقة معامل الخطوة، حيث القيمة الافتراضية له في بايثون هي 1، لذا سنحصل على جميع العناصر الموجودة بين الفهرسَين المذكورين.
شكل هذا التعبير العام هو tuple[x:y:z]، إذ يُشير المعامل z إلى الخطوة. لنُنشِئ قائمةً أكبر، ثم نقسِّمها، ونعطيها القيمة 2 كخطوة:

numbers = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
print(numbers[1:11:2])
(1, 3, 5, 7, 9)

التعبير numbers[1:11:2] سيطبع القيم الموجودة بين رقمين الفهرسين 1 (بما في ذلك العنصر المرتبط بالفهرس 1) و 11 (دون تضمين ذلك العنصر)، ومن ثم ستخبر قيمةُ الخطوة 2 البرنامجَ أنَّ يتخطى عنصرًا بين كل عنصرين.
يمكننا حذف أوّل معاملين واستخدام معامل الخطوة بمفرده بتعبيرٍ برمجيٍ من الشكل tuple[::z]:

print(numbers[::3])
(0, 3, 6, 9, 12)

طبعنا في المثال السابق عناصر numbers بعد ضبط قيمة الخطوة إلى 3، وبالتالي سيتم تخطي عنصرين.

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12

الخلاصة: تقطيع tuples باستخدام أرقام الفهارس الموجبة والسالبة واستعمال معامل الخطوة يسمح لنا بالتحكم بالناتج الذي نريد عرضه.

إضافة بنى tuple إلى بعضها

يمكن أن نُضيف بنى tuple إلى بعضها أو أن «نضربها» (multiply)، تتم عملية الإضافة باستخدام المعامل +، أما عملية الضرب فباستخدام المعامل *.
يمكن أن يُستخدَم المعامل + لإضافة بنيتَي tuple أو أكثر إلى بعضها بعضًا. يمكننا إسناد القيم الموجودة في بنيتَي tuple إلى بنية جديدة:

coral = ('blue coral', 'staghorn coral', 'pillar coral', 'elkhorn coral')
kelp = ('wakame', 'alaria', 'deep-sea tangle', 'macrocystis')

coral_kelp = (coral + kelp)

print(coral_kelp)

الناتج:

('blue coral', 'staghorn coral', 'pillar coral', 'elkhorn coral', 'wakame', 'alaria', 'deep-sea tangle', 'macrocystis')

وصحيحٌ أنَّ المعامل + يمكنه إضافة بنى tuple إلى بعضها، لكن يمكن أن يستعمل لإنشاء بنية tuple جديدة ناتجة عن جمع بنى أخرى، لكن لا يمكنه تعديل بنية tuple موجودة مسبقًا.
أما المعامل * فيمكن استخدامه لضرب بنى tuple، فربما تريد إنشاء نسخ من الملفات الموجودة في أحد المجلدات إلى الخادوم أو مشاركة قائمة بالمقطوعات الموسيقية التي تحبها مع أصدقائك، ففي هذه الحالات سترغب بمضاعفة مجموعات من البيانات (أو «ضربها»).
لنضرب البنية coral بالرقم 2 والبنية kelp بالرقم 3، ثم نسندها إلى بنى tuple جديدة:

multiplied_coral = coral * 2
multiplied_kelp = kelp * 3

print(multiplied_coral)
print(multiplied_kelp)

الناتج:

('blue coral', 'staghorn coral', 'pillar coral', 'elkhorn coral', 'blue coral', 'staghorn coral', 'pillar coral', 'elkhorn coral')
('wakame', 'alaria', 'deep-sea tangle', 'macrocystis', 'wakame', 'alaria', 'deep-sea tangle', 'macrocystis', 'wakame', 'alaria', 'deep-sea tangle', 'macrocystis')

يمكننا باستخدام المعامل * أن نُكرِّر (أو نُضاعِف) بنى tuple بأي عدد من المرات نشاء، مما سينُشِئ بنى tuple جديدة اعتمادًا على محتوى البنى الأصلية.
الخلاصة هي أنَّ بنى tuple يمكن إضافتها إلى بعضها أو ضربها لتشكيل بنى tuple جديدة عبر استخدام المعاملَين + و *.

دوال التعامل مع tuple

هنالك دوال مُضمَّنة في لغة بايثون للتعامل مع بنى tuple، لننظر إلى بعضها.

len()‎

وكما في السلاسل النصية والقوائم، يمكننا حساب طول (أو عدد عناصر) بنية tuple باستخدام الدالة len()‎ حيث نُمرِّر إليها بنية tuple كمعامل (parameter)، كما يلي:

len(coral)

هذه الدالة مفيدة إذا أردنا أن نَضمَن أنَّ لبنية tuple عدد عناصر معيّن، فمثلًا يمكننا الاستفادة من ذلك بمقارنة بنيتين مع بعضهما.
إذا أردنا طباعة عدد عناصر kelp و numbers، فسيظهر الناتج الآتي:

print(len(kelp))
print(len(numbers))

الناتج:

4
13

الناتج أعلاه يشير إلى أنَّ للبنية kelp أربعة عناصر:

kelp = ('wakame', 'alaria', 'deep-sea tangle', 'macrocystis')

أما البنية numbers فتملك ثلاثة عشر عنصرًا:

numbers = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)

وصحيحٌ أنَّ هذه الأمثلة عناصرها قليلة نسبيًا، إلا أنَّ الدالة len()‎ تستطيع أن تخبرنا بعدد عناصر بنى tuple الكبيرة.

الدالتان max()‎ و min()‎

عندما نتعامل مع بنى tuple مكوَّنة من عناصر رقمية (بما فيها الأعداد الصحيحة والأرقام ذات الفاصلة العشرية)، فيمكننا استخدام الدالتين max()‎ و min()‎ للعثور على أكبر وأصغر قيمة موجودة في بنية tuple معيّنة.
تسمح لنا هاتان الدالتان باستخراج معلومات تخص البيانات القابلة للإحصاء، مثل نتائج الامتحانات أو درجات الحرارة أو أسعار المنتجات …إلخ.
لننظر إلى بنية tuple مكونة من أعداد عشرية:

more_numbers = (11.13, 34.87, 95.59, 82.49, 42.73, 11.12, 95.57)

للحصول على القيمة العظمى من بين القيم الآتية فعلينا تمرير بنية tuple إلى الدالة max()‎ كما في max(more_numbers)، وسنستخدم الدالة print()‎ لعرض الناتج:

print(max(more_numbers))
95.59

أعادت الدالة max()‎ أعلى قيمة في بنية more_numbers.
وبشكلٍ شبيهٍ بما سبق نستخدم الدالة min()‎:

print(min(more_numbers))
11.12

أُعيدَ هنا أصغر رقم عشري موجودة في البنية.
يمكن الاستفادة من الدالتين max()‎ و min()‎ كثيرًا للتعامل مع بنى tuple التي تحتوي الكثير من القيم.

كيف تختلف بنى tuple عن القوائم (list)

الفرق الرئيسي بين tuple و list هو عدم القدرة على تعديلها، وهذا يعني أنَّنا لا نستطيع إضافة أو حذف أو استبدال العناصر داخل بنية tuple.
لكن يمكننا إضافة بنيتَي tuple أو أكثر إلى بعضها بعضًا لتشكيل بنية جديدة كما رأينا في أحد الأقسام السابقة.
لتكن لدينا البنية coral الآتية:

coral = ('blue coral', 'staghorn coral', 'pillar coral', 'elkhorn coral')

لنقل أننا نريد استبدال العنصر 'blue coral' ووضع العنصر 'black coral' بدلًا منه. فلو حاولنا تغيير بنية tuple بنفس الطريقة التي نُعدِّل فيها القوائم بكتابة:

coral[0] = 'black coral'

فستظهر رسالة خطأ كالآتية:

TypeError: 'tuple' object does not support item assignment

وذلك بسبب عدم إمكانية تعديل بنى tuple.
إذا أنشأنا بنية tuple ثم قررنا أنَّ ما نحتاج له هو بنية list، فيمكننا تحويلها إلى قائمة list، وذلك بالدالة list()‎:

list(coral)

أصبحت بنية coral قائمةً الآن:

coral = ['blue coral', 'staghorn coral', 'pillar coral']

يمكننا أن نلاحظ أنَّ بنية tuple تحوَّلتَ إلى قائمة list لأنَّ الأقواس المحيطة بالقيم أصبح مربعة الشكل.
وبشكلٍ شبيهٍ بما سبق، نستطيع تحويل القوائم من النوع list إلى tuple باستخدام الدالة tuple()‎.

الخلاصة

نوع البيانات tuple هو مجموعةٌ من البيانات المتسلسلة التي لا يمكن تعديلها، ويوفِّر تحسينًا في أداء برامجك لأنه أسرع معالجةً من القوائم في بايثون. وعندما يراجع الآخرون شيفرتك فسيعلمون من استخدامك لبنى tuple أنك لا تريد تعديل هذه القيم.
شرحنا في هذا الدرس الميزات الأساسية لبنى tuple بما في ذلك الفهارس وتقطيعها وتجميعها، وعرضنا بعض الدوال المُضمَّنة المتوافرة لهذا النوع من البيانات.

هذه المقالة جزء من سلسة مقالات حول تعلم البرمجة في بايثون 3.

ترجمة –وبتصرّف– للمقال Understanding Tuples in Python 3 لصاحبته Lisa Tagliaferri

اقرأ أيضًا

• المقالة التالية: فهم القواميس في بايثون 3
• المقالة السابقة: فهم كيفية استعمال List Comprehensions في بايثون 3
• المرجع الشامل إلى تعلم لغة بايثون
• كتاب البرمجة بلغة بايثون
• دليلك الشامل إلى أنواع البيانات

توفر List Comprehensions طريقةً مختصرةً لإنشاء القوائم بناءً على قوائم موجودة مسبقًا. فعند استخدام list comprehensions فيمكن بناء القوائم باستخدام أيّ نوع من البيانات المتسلسلة التي يمكن الدوران على عناصرها عبر حلقات التكرار، بما في ذلك السلاسل النصية و tuples.
من ناحية التركيب اللغوي، تحتوي list comprehensions على عنصر يمكن المرور عليه ضمن تعبيرٍ متبوعٍ بحلقة for. ويمكن أن يُتبَع ما سبق بتعابير for أو if إضافية، لذا سيساعدك الفهم العميق لحلقات for والعبارات الشرطية في التعامل مع list comprehensions.
توفِّر list comprehensions طريقةً مختلفةً لإنشاء القوائم وغيرها من أنواع البيانات المتسلسلة. وعلى الرغم من إمكانية استخدام الطرائق الأخرى للدوران، مثل حلقات for، لإنشاء القوائم، لكن من المفضَّل استعمال list comprehensions لأنها تقلِّل عدد الأسطر الموجودة في برنامجك.

List Comprehensions

يمكن بناء list comprehensions في بايثون كالآتي:

list_variable = [x for x in iterable]

ستُسنَد القائمة، أو أي نوع من البيانات يمكن المرور على عناصره، إلى متغير. المتغيرات الإضافية –التي تُشير إلى عناصر موجودة ضمن نوع البيانات الذي يمكن المرور على عناصره– تُبنى حول عبارة for. والكلمة المحجوزة in تستعمل بنفس استعمالها في حلقات for وذلك لمرور على عناصر iterable.
لننظر إلى مثالٍ يُنشِئ قائمةً مبنيةً على سلسلةٍ نصية:

shark_letters = [letter for letter in 'shark']
print(shark_letters)

أسندنا في المثال السابق قائمةً جديدةً إلى المتغير shark_letters، واستعملنا المتغير letter للإشارة إلى العناصر الموجودة ضمن السلسلة النصية 'shark'.
استعملنا بعد ذلك الدالة print()‎ لكي نتأكد من القائمة الناتجة والمُسنَدة إلى المتغير shark_letters، وحصلنا على الناتج الآتي:

['s', 'h', 'a', 'r', 'k']

القائمة التي أنشأناها باستخدام list comprehensions تتألف من العناصر التي تكوِّن السلسلة النصية 'shark'، وهي كل حرف في الكلمة shark.
يمكن إعادة كتابة تعابير list comprehensions كحلقات for، لكن لاحظ أنَّك لا تستطيع إعادة كتابة كل حلقة for بصيغة list comprehensions.
لنعد كتابة المثال السابق الذي أنشأنا فيه القائمة shark_letters باستخدام حلقة for، وهذا سيساعدنا في فهم كيف تعمل list comprehensions عملها:

shark_letters = []

for letter in 'shark':
    shark_letters.append(letter)

print(shark_letters)

عند إنشائنا للقائمة عبر استخدام الحلقة for، فيجب تهيئة المتغير الذي سنُسنِد العناصر إليه كقائمة فارغة، وهذا ما فعلناه في أوّل سطر من الشيفرة السابقة. ثم بدأت حلقة for بالدوران على عناصر السلسلة النصية 'shark' مستعملةً المتغير letter للإشارة إلى قيمة العنصر الحالي. ومن ثم أضفنا كل عنصر في السلسلة النصية إلى القائمة ضمن حلقة for وذلك باستخدام الدالة list.append(x).
الناتج من حلقة for السابقة يماثل ناتج list comprehension في المثال أعلاه:

['s', 'h', 'a', 'r', 'k']

الخلاصة: يمكن إعادة كتابة List comprehensions كحلقات for، لكن بعض حلقات for يمكن إعادة كتابتها لتصبح List comprehensions لتقليل كمية الشيفرات المكتوبة.

استخدام التعابير الشرطية مع List Comprehensions

يمكن استخدام التعابير الشرطية في list comprehension لتعديل القوائم أو أنواع البيانات المتسلسلة الأخرى عند إنشاء قوائم جديدة.
لننظر إلى مثالٍ عن استخدام العبارة الشرطية if في تعبير list comprehension:

fish_tuple = ('blowfish', 'clownfish', 'catfish', 'octopus')

fish_list = [fish for fish in fish_tuple if fish != 'octopus']
print(fish_list)

استعملنا المتغير fish_tuple الذي من نوع البيانات tuple كأساس للقائمة الجديدة التي سنُنشِئها التي تسمى fish_list. استعملنا for و in كما في القسم السابق، لكننا أضفنا هنا العبارة الشرطية if. ستؤدي العبارة الشرطية if إلى إضافة العناصر غير المساوية للسلسلة النصية 'octopus'، لذا ستحتوي القائمة الجديدة على العناصر الموجودة في بنية tuple والتي لا تُطابِق الكلمة 'octopus'.
عند تشغيل البرنامج السابق فسنلاحظ أنَّ القائمة fish_list تحتوي على نفس العناصر التي كانت موجودة في fish_tuple لكن مع حذف العنصر 'octopus':

['blowfish', 'clownfish', 'catfish']

أي أصبحت القائمة الجديدة تحتوي على بنية tuple الأصلية لكن ما عدا السلسلة النصية التي استثنيناها عبر التعبير الشرطي.
سنُنشِئ مثالًا آخر يستعمل المعاملات الرياضية والأرقام الصحيحة والدالة range()‎:

number_list = [x ** 2 for x in range(10) if x % 2 == 0]
print(number_list)

القائمة التي ستُنشَأ باسم number_list ستحتوي على مربع جميع القيم الموجودة من المجال 0 إلى 9 لكن إذا كان الرقم قابلًا للقسمة على 2. وستبدو المخرجات كالآتية:

[0, 4, 16, 36, 64]

دعنا نُفصِّل ما الذي يفعله تعبير list comprehension السابق، ودعنا نفكِّر بالذي سيظهر إذا استعملنا التعبير x for x in range(10) فقط. يجب أن يبدو برنامجنا الصغير كالآتي:

number_list = [x for x in range(10)]
print(number_list)

الناتج:

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

لنضف العبارة الشرطية الآن:

number_list = [x for x in range(10) if x % 2 == 0]
print(number_list)

الناتج:

[0, 2, 4, 6, 8]

أدّت العبارة الشرطية if إلى قبول العناصر القابلة للقسمة على 2 فقط وإضافتها إلى القائمة، مما يؤدي إلى حذف جميع الأرقام الفردية.
يمكننا الآن استخدام معامل رياضي لتربيع قيمة المتغير x:

number_list = [x ** 2 for x in range(10) if x % 2 == 0]
print(number_list)

أي ستُربَّع قيم القائمة السابقة ‎[0, 2, 4, 6, 8] وسيُخرَج الناتج الآتي:

[0, 4, 16, 36, 64]

يمكننا أيضًا استعمال ما يشبه عبارات if المتشعبة في تعابير list comprehension:

number_list = [x for x in range(100) if x % 3 == 0 if x % 5 == 0]
print(number_list)

سيتم التحقق أولًا أنَّ المتغير x قابل للقسمة على الرقم 3، ثم سنتحقق إن كان المتغير x قابل للقسمة على الرقم 5، وإذا حقَّق المتغير x الشرطين السابقين فسيُضاف إلى القائمة، وسيُظهَر في الناتج:

[0, 15, 30, 45, 60, 75, 90]

الخلاصة: يمكن استخدام عبارات if الشرطية لتحديد ما هي العناصر التي نريد إضافتها إلى القائمة الجديدة.

حلقات التكرار المتشعبة في تعابير List Comprehension

يمكن استعمال حلقات التكرار المتشعبة لإجراء عدِّة عمليات دوران متداخلة في برامجنا.
سننظر في هذا القسم إلى حلقة for متشعبة وسنحاول تحويلها إلى تعبير list comprehension.
هذه الشيفرة ستُنشِئ قائمةً جديدةً بالدوران على قائمتين وبإجراء عمليات رياضية عليها:

my_list = []

for x in [20, 40, 60]:
    for y in [2, 4, 6]:
        my_list.append(x * y)

print(my_list)

سنحصل على الناتج الآتي عند تشغيل البرنامج:

[40, 80, 120, 80, 160, 240, 120, 240, 360]

الشيفرة السابقة تضرب العناصر الموجودة في أوّل قائمة بالعناصر الموجودة في ثاني قائمة في كل دورة.
لتحويل ما سبق إلى تعبير list comprehension، وذلك باختصار السطرين الموجودين في الشيفرة السابقة وتحويلهما إلى سطرٍ وحيدٍ، الذي يبدأ بإجراء العملية x*y، ثم ستلي هذه العملية حلقة for الخارجية، ثم يليها حلقة for الداخلية؛ وسنضيف تعبير print()‎ للتأكد أنَّ ناتج القائمة الجديدة يُطابِق ناتج البرنامج الذي فيه حلقتين متداخلتين:

my_list = [x * y for x in [20, 40, 60] for y in [2, 4, 6]]
print(my_list)

الناتج:

[40, 80, 120, 80, 160, 240, 120, 240, 360]

أدى استعمال تعبير list comprehension في المثال السابق إلى تبسيط حلقتَي for لتصبحا سطرًا وحيدًا، لكن مع إنشاء نفس القائمة والتي ستُسنَد إلى المتغير my_list.
توفِّر لنا تعابير list comprehension طريقةً بسيطةً لإنشاء القوائم، مما يسمح لنا باختصار عدِّة أسطر إلى سطرٍ وحيد. لكن من المهم أن تبقي في ذهنك أنَّ سهولة قراءة الشيفرة لها الأولوية دومًا، لذا إذا أصبحتَ تعابير list comprehension طويلةً جدًا ومعقدة، فمن الأفضل حينها تحويلها إلى حلقات تكرار عادية.

الخلاصة

تسمح تعابير list comprehension لنا بتحويل قائمة أو أي نوع من البيانات المتسلسلة إلى سلسلةٍ جديدة، ولها شكلٌ بسيطٌ يُقلِّل عدد الأسطر التي نكتبها.
تتبع تعابير list comprehension شكلًا رياضيًا معيّنًا، لذا قد يجدها المبرمجون أولو الخلفية الرياضية سهلة الفهم.
وصحيحٌ أنَّ تعابير list comprehension تختصر الشيفرةـ لكن من المهم جعل سهولة قراءة الشيفرة من أولوياتنا، وحاول تجنّب الأسطر الطويلة لتسهيل قراءة الشيفرة.

هذه المقالة جزء من سلسة مقالات حول تعلم البرمجة في بايثون 3.

ترجمة –وبتصرّف– للمقال Understanding List Comprehensions in Python 3 لصاحبته Lisa Tagliaferri

اقرأ أيضًا

• المقالة التالية: فهم نوع البيانات Tuples في بايثون 3
• المقالة السابقة:  كيفية استخدام توابع القوائم في بايثون 3
• المرجع الشامل إلى تعلم لغة بايثون
• كتاب البرمجة بلغة بايثون

يتضمّن بايثون عددًا من هياكل البيانات، بما في ذلك القوائم. تمكّن هياكل البيانات من تنظيم البيانات وتخزينها عبر توابع خاصة مُضمّنة في بايثون.

للاستفادة من محتويات هذه المقالة، ينبغي أن تكون على إلمام بأساسيات القوائم، وصياغتها وكيفية فهرستها. يمكنك تعلم ذلك من المقالة السابقة: القوائم في بايثون 3.

سنتعرف على التوابع المُضمنة التي يمكن استخدامها مع القوائم. ونتعلم كيفية إضافة عناصر إلى القائمة وكيفية إزالتها، وتوسيع القوائم وترتيبها، وغير ذلك.

القوائم أنواعٌ قابلةٌ للتغيير (mutable) على عكس السلاسل النصية التي لا يمكن تغييرها، فعندما تستخدم تابعًا على قائمة ما، ستؤثر في القائمة نفسها، وليس في نسخة منها.

سنعمل في هذه المقالة على قائمة تمثل حوض سمك، إذ ستحوي القائمة أسماء أنواع الأسماك الموجودة في الحوض، وسنعدلها كلما أضفنا أسماكًا أو أزلناها من الحوض.

التابع list.append()‎‎

يضيف التابع list.append(x)‎ عنصرًا (x) إلى نهاية القائمة. يُعرّف المثال التالي قائمةً تمثل الأسماك الموجودة في حوض السمك.

fish = ['barracuda','cod','devil ray','eel']

تتألف هذه القائمة من 4 سلاسل نصية، وتتراوح فهارسها من 0 إلى 3.

سنضيف سمكة جديدة إلى الحوض، ونود بالمقابل أن نضيف تلك السمكة إلى قائمتنا. سنمرّر السلسلة النصية flounder التي تمثل نوع السمكة الجديدة إلى التابع list.append()‎، ثم نطبع قائمتنا المعدلة لتأكيد إضافة العنصر.

fish.append('flounder')
print(fish)    #  ['barracuda', 'cod', 'devil ray', 'eel', 'flounder']

الآن، صارت لدينا قائمة من 5 عناصر، تنتهي بالعنصر الذي أضفناه للتو عبر التابع append()‎.

التابع list.insert()‎

يأخذ التابع list.insert (i,x)‎ وسيطين: الأول i يمثِّل الفهرس الذي ترغب في إضافة العنصر عنده، و x يمثل العنصر نفسه.

لقد أضفنا إلى حوض السمك سمكة جديدة من نوع anchovy. ربما لاحظت أنّ قائمة الأسماك مرتبة ترتيبًا أبجديًا حتى الآن. لهذا السبب لا نريد إفساد الترتيب، لذا لن نضيف السلسلة النصية anchovy إلى نهاية القائمة باستخدام الدالة list.append()‎. بدلًا من ذلك، سنستخدم التابع list.insert()‎ لإضافة anchovy إلى بداية القائمة، أي عند الفهرس 0:

fish.insert(0,'anchovy')
print(fish)    #  ['anchovy', 'barracuda', 'cod', 'devil ray', 'eel', 'flounder']

في هذه الحالة، أضفنا العنصر إلى بداية القائمة. ستتقدم فهارس العناصر التالية خطوةً واحدةً إلى الأمام. لذلك، سيصبح العنصر barracuda عند الفهرس 1، والعنصر cod عند الفهرس 2، والعنصر flounder - الأخير - عند الفهرس 5.

سنحضر الآن سمكة من نوع damselfish إلى الحوض، ونرغب في الحفاظ على الترتيب الأبجدي لعناصر القائمة أعلاه، لذلك سنضع هذا العنصر عند الفهرس 3: fish.insert(3,'damselfish')‎.

التابع list.extend()‎

إذا أردت أن توسّع قائمة بعناصر قائمة أخرى، فيمكنك استخدام التابع list.extend(L)‎، والذي يأخذ قائمة كمعامل.

سنضع في الحوض أربعة أسماك جديدة. أنواع هذه الأسماك مجموعة معًا في القائمة more_fish:

more_fish = ['goby','herring','ide','kissing gourami']

سنضيف الآن عناصر القائمة more_fish إلى قائمة الأسماك، ونطبع القائمة لنتأكد من أنّ عناصر القائمة الثانية قد ضُمّت إليها:

fish.extend(more_fish)
print(fish)

ستطبع بايثون القائمة التالية:

['anchovy', 'barracuda', 'cod', 'devil ray', 'eel', 'flounder', 'goby', 'herring', 'ide', 'kissing gourami']

في هذه المرحلة، صارت القائمة fish تتألف من 10 عناصر.

التابع list.remove()‎

لإزالة عنصر من قائمة، استخدم التابع list.remove(x)‎، والذي يزيل أول عنصر من القائمة له القيمة المُمرّرة x.

جاءت مجموعة من العلماء المحليين لزيارة الحوض. سيجرون أبحاثًا عن النوع kissing gourami، وطلبوا استعارة السمكة kissing gourami، لذلك نود إزالة العنصر kissing gourami من القائمة لنعكس هذا التغيير:

fish.remove('kissing gourami')
print(fish)

والمخرجات ستكون:

['anchovy', 'barracuda', 'cod', 'devil ray', 'eel', 'flounder', 'goby', 'herring', 'ide']

بعد استخدام التابع list.remove()‎، لم يعد العنصر kissing gourami موجودًا في القائمة.

في حال مرّرت عنصرًا x غير موجود في القائمة إلى التابع list.remove()‎، فسيُطلق الخطأ التالي:

ValueError: list.remove(x): x not in list

التابع list.remove()‎ لن يزيل إلا أول عنصر تساوي قيمته قيمة العنصر المُمرّر إلى التابع، لذلك إن كانت لدينا سمكتان من النوع kissing gourami في الحوض، وأعرنا إحداهما فقط للعلماء، فإنّ التعبير fish.remove('kissing gourami')‎ لن يمحو إلا العنصر الأول المطابق فقط.

التابع list.pop()‎

يعيد التابع list.pop ()‎ العنصر الموجود عند الفهرس المحدد من القائمة، ثم يزيل ذلك العنصر. تشير الأقواس المربعة حول i إلى أنّ هذا المعامل اختياري، لذا، إذا لم تحدد فهرسًا (كما في fish.pop()‎)، فسيُعاد العنصر الأخير ثم يُزال.

لقد أصبح حجم السمكة devil ray كبيرًا جدًا، ولم يعد الحوض يسعها، ولحسن الحظ أنّ هناك حوض سمك في بلدة مجاورة يمكنه استيعابها. سنستخدم التابع ‎.‎pop()‎، ونمرر إليه العدد 3، الذي يساوي فهرس العنصر devil ray، بقصد إزالته من القائمة. بعد إعادة العنصر، سنتأكد من أننا أزلنا العنصر الصحيح.

print(fish.pop(3)) # devil ray
print(fish)            # ['anchovy', 'barracuda', 'cod', 'eel', 'flounder', 'goby', 'herring', 'ide']

باستخدام التابع ‎.pop()‎ تمكّنا من إعادة وإزالة ray devil من قائمة الأسماك.

إذا لم نمرر أيّ معامل إلى هذا التابع، ونفّذنا التعبير fish.pop()‎، فسيُعاد العنصر الأخير ide ثم يُزَال من القائمة.

التابع list.index()‎

يصعب في القوائم الكبيرة تحديد فهارس العناصر التي تحمل قيمة معينة. لأجل ذلك، يمكننا استخدام التابع list.index(x)‎، حيث يمثل الوسيطx قيمة العنصر المبحوث عنه، والذي نريد إعادة فهرسه. إذا كان هناك أكثر من عنصر واحد يحمل القيمة x، فسيُعَاد فهرس العنصر الأول.

print(fish)    # ['anchovy', 'barracuda', 'cod', 'eel', 'flounder', 'goby', 'herring', 'ide']

print(fish.index('herring'))    # 6

سوف يُطلق خطأ في حال مرّرنا قيمة غير موجودة في القائمة إلى التابع ‎.index()‎.

التابع list.copy()‎

أحيانُا نرغب في تعديل عناصر قائمةٍ والتجريب عليها، مع الحفاظ على القائمة الأصلية دون تغيير؛ يمكننا في هذه الحالة استخدام التابع list.copy()‎ لإنشاء نسخة من القائمة الأصلية.

في المثال التالي، سنمرّر القيمة المعادة من fish.copy()‎ إلى المتغير fish_2، ثم نطبع قيمة fish_2 للتأكد من أنها تحتوي على نفس عناصر القائمة fish.

fish_2 = fish.copy()
print(fish_2)      #  ['anchovy', 'barracuda', 'cod', 'eel', 'flounder', 'goby', 'herring', 'ide']

في هذه المرحلة، القائمتان fish و fish_2 متساويتان.

التابع list.reverse()‎

يمكننا عكس ترتيب عناصر قائمة باستخدام التابع list.reverse()‎. في المثال التالي سنستخدم التابع ‎.reverse()‎ مع القائمة fish لعكس ترتيب عناصرها.

fish.reverse()
print(fish)    #  ['ide', 'herring', 'goby', 'flounder', 'eel', 'cod', 'barracuda', 'anchovy']

بعد استخدام التابع ‎.reverse()‎، صارت القائمة تبدأ بالعنصر ide، والذي كان في نهاية القائمة من قبل، كما ستنتهي القائمة بالعنصر anchovy، والذي كان في بداية القائمة من قبل.

التابع list.count()‎

يعيد التابع list.count(x)‎ عدد مرات ظهور القيمة x في القائمة. هذا التابع مفيد في حال كنا نعمل على قائمة طويلة بها الكثير من القيم المتطابقة.

إذا كان حوض السمك كبيرًا، على سبيل المثال، وكانت عندنا عدة أسماك من النوع neon tetra، فيمكننا استخدام التابع ‎.count()‎ لتحديد العدد الإجمالي لأسماك هذا النوع.

في هذا المثال سنحسب عدد مرات ظهور العنصر goby:

print(fish.count('goby'))       #  1

تظهر السلسلة النصية goby مرةً واحدةً فقط في القائمة، لذا سيُعيد التابع ‎.count()‎ العدد 1.

يمكننا استخدام هذا التابع أيضًا مع قائمة مكوَّنة من أعداد صحيحة. المثال التالي يوضح ذلك.

يتتبع المشرفون على الحوض أعمار الأسماك الموجودة فيه للتأكد من أنّ وجباتها الغذائية مناسبة لأعمارها. هذه القائمة الثانية المُسماة fish_ages تتوافق مع أنواع السمك في القائمة fish.

نظرًا لأنّ الأسماك التي لا يتجاوز عمرها عامًا واحدًا لها احتياجات غذائية خاصة، فسنحسب عدد الأسماك التي عمرها عامًا واحدًا:

fish_ages = [1,2,4,3,2,1,1,2]
print(fish_ages.count(1))    #  3

يظهر العدد الصحيح 1 في القائمة fish_ages ثلاث مرات، لذلك يعيد التابع ‎.count()‎ العدد 3.

التابع list.sort()‎

يُستخدم التابع list.sort()‎ لترتيب عناصر القائمة التي استُدعِي معها .

سنستخدم قائمة الأعداد الصحيحة fish_ages لتجريب التابع ‎.sort()‎:

fish_ages.sort()
print(fish_ages)    #  [1, 1, 1, 2, 2, 2, 3, 4]

باستدعاء التابع ‎.sort()‎ مع القائمة fish_ages، ستُعاد قائمة الأعداد الصحيحة مرتبةً.

التابع list.clear()‎

بعد الانتهاء من العمل على قائمة ما، يمكنك إزالة جميع القيم الموجودة فيها باستخدام التابع list.clear()‎.

قررت الحكومة المحلية الاستيلاء على حوض السمك الخاص بنا، وجعله مساحة عامة يستمتع بها سكان مدينتنا. نظرًا لأننا لم نعد نعمل على الحوض، فلم نعد بحاجة إلى الاحتفاظ بقائمة الأسماك، لذلك سنزيل عناصر القائمة fish:

fish.clear()
print(fish)    #  []

نرى في المخرجات أقواسًا معقوفة نتيجة استدعاء التابع ‎.clear()‎ على القائمة fish، وهذا تأكيد على أنّ القائمة أصبحت خالية من جميع العناصر.

خلاصة

لمَّا كانت القوائم تسلسلات قابلة للتغيير (mutable)، فإنّها هياكلُ بيانات مرنة ومفيدة للغاية. كما تتيح لنا توابع القوائم إجراء العديد من العمليات على القوائم بسهولة، إذ يمكننا استخدام التوابع لتعديل القوائم وترتيبها ومعالجتها بفعالية.

هذه المقالة جزء من سلسة مقالات حول تعلم البرمجة في بايثون 3.

ترجمة -وبتصرّف- للمقال How To Use List Methods in Python 3 لصاحبته Lisa Tagliaferri

اقرأ أيضًا

• المقالة التالية: فهم كيفية استعمال List Comprehensions في بايثون 3
• المقالة السابقة: مدخل إلى القوائم في بايثون 3
• المرجع الشامل إلى تعلم لغة بايثون
• كتاب البرمجة بلغة بايثون

القائمة هي بنية بيانات في بايثون، وهي عبارة عن تسلسل مُرتّب من العناصر قابل للتغيير (mutable).

القوائم مناسبة لتجميع العناصر المترابطة، إذ تمكّنك من تجميع البيانات المتشابهة، أو التي تخدم غرضًا معيّنا معًا، وتكثيف الشيفرة البرمجية، وتنفيذ التوابع والعمليات على عدة قيم في وقت واحد.

القوائم في بايثون وغيرها من هياكل البيانات المركبة تساعد على تمثيل المجموعات، مثل مجموعة الملفات في مجلد على حاسوبك، أو قوائم التشغيل، ورسائل البريد الإلكتروني، وغير ذلك.

في المثال التالي، سننشئ قائمةً تحتوي على عناصر من نوع السلاسل النصية:

sea_creatures = ['shark', 'cuttlefish', 'squid', 'mantis shrimp', 'anemone']

عندما نطبع القائمة، فإنّ المخرجات ستشبه القائمة التي أنشأناها:

print(sea_creatures)    #  ['shark', 'cuttlefish', 'squid', 'mantis shrimp', 'anemone']

باعتبارها تسلسلًا مرتبًا من العناصر، يمكن استدعاء أيّ عنصر من القائمة عبر الفهرسة. القوائم هي بيانات مركبة تتألف من أجزاء أصغر، وتتميز بالمرونة، إذ يمكن إضافة عناصر إليها، وإزالتها، وتغييرها. عندما تحتاج إلى تخزين الكثير من القيم، أو التكرار (iterate) عليها، وتريد أن تكون قادرًا على تعديل تلك القيم بسهولة، فالقوائم هي خيارك الأفضل.

سنتعرف في هذه المقالة على القوائم وتوابعها وكيفية استخدامها.

فهرسة القوائم (Indexing Lists)

كل عنصر في القائمة يقابله رقم يمثل فهرسَ ذلك العنصر، والذي هو عدد صحيح، فهرس العنصر الأول في القائمة هو 0.

هذا تمثيل لفهارس القائمة sea_creatures:

يبدأ العنصر الأول، أي السلسلة النصية shark، عند الفهرس 0، وتنتهي القائمة عند الفهرس 4 الذي يقابل العنصر anemone.

نظرًا لأنّ كل عنصر في قوائم بايثون يقابله رقم فهرس، يمكننا الوصول إلى عناصر القوائم ومعالجتها كما نفعل مع أنواع البيانات المتسلسلة الأخرى.

يمكننا الآن استدعاء عنصر من القائمة من خلال رقم فهرسه:

print(sea_creatures[1])       #  cuttlefish

تتراوح أرقام الفهارس في هذه القائمة بين 0 و 4، كما هو موضح في الجدول أعلاه. المثال التالي يوضح ذلك:

sea_creatures[0] = 'shark'
sea_creatures[1] = 'cuttlefish'
sea_creatures[2] = 'squid'
sea_creatures[3] = 'mantis shrimp'
sea_creatures[4] = 'anemone'

إذا استدعينا القائمة sea_creatures برقم فهرس أكبر من 4، فسيكون الفهرس خارج النطاق، وسيُطلَق الخطأ IndexError:

print(sea_creatures[18])

والمخرجات ستكون:

IndexError: list index out of range

يمكننا أيضًا الوصول إلى عناصر القائمة بفهارس سالبة، والتي تُحسَب من نهاية القائمة، بدءًا من ‎-1. هذا مفيد في حال كانت لدينا قائمة طويلة، وأردنا تحديد عنصر في نهايته.

بالنسبة لقائمة sea_creatures، تبدو الفهارس السالبة كما يلي:

في المثال التالي، سنطبع العنصر squid باستخدام فهرس سالب:

print(sea_creatures[-3])     #  squid

يمكننا ضم (concatenate) عنصر يحتوي سلسلة نصية مع سلسلة نصبة أخرى باستخدام العامل +:

print('Sammy is a ' + sea_creatures[0])     # Sammy is a shark

لقد ضممنا السلسلة النصية Sammy is a مع العنصر ذي الفهرس 0. يمكننا أيضًا استخدام العامل + لضمّ قائمتين أو أكثر معًا (انظر الفقرة أدناه):

تساعدنا الفهارس على الوصول إلى أيّ عنصر من عناصر القائمة والعمل عليه.

تعديل عناصر القائمة

يمكننا استخدام الفهرسة لتغيير عناصر القائمة، عن طريق إسناد قيمة إلى عُنصر مُفهرس من القائمة. هذا يجعل القوائم أكثر مرونة، ويسهّل تعديل وتحديث عناصرها.

إذا أردنا تغيير قيمة السلسلة النصية للعنصر الموجود عند الفهرس 1، من القيمة cuttlefish إلى octopus، فيمكننا القيام بذلك على النحو التالي:

sea_creatures[1] = 'octopus'

الآن، عندما نطبع sea_creatures، ستكون النتيجة:

print(sea_creatures)    # ['shark', 'octopus', 'squid', 'mantis shrimp', 'anemone']

يمكننا أيضًا تغيير قيمة عنصر باستخدام فهرس سالب:

sea_creatures[-3] = 'blobfish'
print(sea_creatures)      #   ['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone']

الآن استبدلنا بالسلسلة squid السلسلة النصية blobfish الموجودة عند الفهرس السالب ‎-3 (والذي يتوافق مع الفهرس الموجب 2).

اقتطاع القوائم (Slicing Lists)

يمكننا أيضا استدعاء عدة عناصر من القائمة. لنفترض أننا نرغب في طباعة العناصر الموجودة في وسط القائمة sea_creatures، يمكننا القيام بذلك عن طريق اقتطاع شريحة (جزء) من القائمة.

يمكننا باستخدام الشرائح استدعاء عدة قيم عن طريق إنشاء مجال من الفهارس مفصولة بنقطتين [x: y]:

print(sea_creatures[1:4])    # ['octopus', 'blobfish', 'mantis shrimp']

عند إنشاء شريحة، كما في [‎1: 4]، يبدأ الاقتطاع من العنصر ذي الفهرس الأول (مشمولًا)، وينتهي عند العنصر ذي الفهرس الثاني (غير مشمول)، لهذا طُبعَت في مثالنا أعلاه العناصر الموجودة في المواضع، 1، و 2، و 3.

إذا أردنا تضمين أحد طرفي القائمة، فيمكننا حذف أحد الفهرسَين في التعبير [x: y]. على سبيل المثال، إذا أردنا طباعة العناصر الثلاثة الأولى من القائمة sea_creatures، يمكننا فعل ذلك عن طريق كتابة:

print(sea_creatures[:3])     #  ['shark', 'octopus', 'blobfish']

لقد تم طبع العناصر من بداية القائمة حتّى العنصرٍ ذي الفهرس 3.

لتضمين جميع العناصر الموجودة في نهاية القائمة، سنعكس الصياغة:

print(sea_creatures[2:])    #  ['blobfish', 'mantis shrimp', 'anemone']

يمكننا أيضًا استخدام الفهارس السالبة عند اقتطاع القوائم، تمامًا كما هو الحال مع الفهارس الموجبة:

print(sea_creatures[-4:-2])         #  ['octopus', 'blobfish']
print(sea_creatures[-3:])           #  ['blobfish', 'mantis shrimp', 'anemone']

هناك معامل آخر يمكننا استخدامه في الاقتطاع، ويشير إلى عدد العناصر التي يجب أن يتم القفز عليها (أو الخطوة) بعد استرداد العنصر الأول من القائمة. حتى الآن، لقد أغفلنا المعامل stride، وستعطيه بايثون القيمة الافتراضية 1، ما يعني أنه سيتم استرداد كل العناصر الموجودة بين الفهرسَين المحددين.

ستكون لصياغة على الشكل التالي [x: y: z]، إذ يشير z إلى الخطوة (stride). في المثال التالي، سننشئ قائمة كبيرة، ثم نقتطعها، مع خطوة اقتطاع تساوي 2:

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

print(numbers[1:11:2])       #  [1, 3, 5, 7, 9]

سيطبع التعبير numbers[‎1: 11: 2]‎ القيم ذات الفهارس المحصورة بين 1 (مشمولة) و 11 (غير مشمولة)، وسيقفز البرنامج بخطوتين كل مرة، ويطبع العناصر المقابلة.

يمكننا حذف المُعاملين الأوّليين، واستخدام الخطوة وحدها كمعامل وفق الصياغة التالية: [‎::z]:

print(numbers[::3])      #  [0, 3, 6, 9, 12]

عند طباعة القائمة ‎numbers مع تعيين الخطوة عند القيمة 3، فلن تُطبع إلا العناصر التي فهارسها من مضاعفات 3: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 يجعل استخدام الفهارس الموجبة والسالبة ومعامل الخطوة في اقتطاع القوائم التحكم في القوائم ومعالجتها أسهل وأكثر مرونة.

تعديل القوائم بالعوامل

يمكن استخدام العوامل لإجراء تعديلات على القوائم. سننظر في استخدام العاملين + و * ومقابليهما المركبين ‎+=‎ و ‎*=‎‎.

يمكن استخدام العامل + لضمّ (concatenate) قائمتين أو أكثر معًا:

sea_creatures = ['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone']
oceans = ['Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic']

print(sea_creatures + oceans)

والمخرجات هي:

['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic']

يمكن استخدام العامل + لإضافة عنصر (أو عدة عناصر) إلى نهاية القائمة. لكن تذكر أن تضع العنصر بين قوسين مربعين:

sea_creatures = sea_creatures + ['yeti crab']
print (sea_creatures)    #   ['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']

يمكن استخدام العامل * لمضاعفة القوائم (multiply lists). ربما تحتاج إلى عمل نُسِخٍ لجميع الملفات الموجودة في مجلد على خادم، أو مشاركة قائمة أفلام مع الأصدقاء؛ ستحتاج في هذه الحالات إلى مضاعفة مجموعات البيانات.

سنضاعف القائمة sea_creatures مرتين، والقائمة oceans ثلاث مرات:

print(sea_creatures * 2)
print(oceans * 3)

والنتيجة ستكون:

['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab', 'shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']
['Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic', 'Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic', 'Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic']

يمكننا باستخدام العامل * نسخ القوائم عدة مرات.

يمكننا أيضًا استخدام الشكلين المركبين للعاملين + و * مع عامل الإسناد =. يمكن استخدام العاملين المركبين ‎+=‎ و ‎*=‎ لملء القوائم بطريقة سريعة ومُؤتمتة. يمكنك استخدام هذين العاملين لملء القوائم بعناصر نائبة (placeholders) يمكنك تعديلها في وقت لاحق بالمدخلات المقدمة من المستخدم على سبيل المثال.

في المثال التالي، سنضيف عنصرًا إلى القائمة sea_creatures. سيعمل هذا العنصر مثل عمل العنصر النائب، ونود إضافة هذا العنصر النائب عدة مرات. لفعل ذلك، سنستخدم ‎+=‎ العامل مع الحلقة for.

for x in range(1,4):
    sea_creatures += ['fish']
    print(sea_creatures)

والمخرجات ستكون:

['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab', 'fish']
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab', 'fish', 'fish']
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab', 'fish', 'fish', 'fish']

سيُضاف لكل تكرار في الحلقة for عنصر fish إلى القائمة sea_creatures.

العامل ‎*=‎ يتصرف بطريقة مماثلة:

sharks = ['shark']

for x in range(1,4):
    sharks *= 2
    print(sharks)

الناتج سيكون:

['shark', 'shark']
['shark', 'shark', 'shark', 'shark']
['shark', 'shark', 'shark', 'shark', 'shark', 'shark', 'shark', 'shark']

إزالة عنصر من قائمة

يمكن إزالة العناصر من القوائم باستخدام التعبير del. سيؤدي ذلك إلى حذف العنصر الموجود عند الفهرس المحدد.

سنزيل من القائمة sea_creatures العنصر octopus. هذا العنصر موجود عند الفهرس 1. لإزالة هذا العنصر، سنستخدم العبارة del ثم نستدعي متغير القائمة وفهرس ذلك العنصر:

sea_creatures =['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']

del sea_creatures[1]
print(sea_creatures)     #  ['shark', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']

الآن، العنصر الموجود عند الفهرس 1، أي السلسلة النصية octopus، لم يعد موجودًا في قائمتنا.

يمكننا أيضًا تحديد مجال مع العبارة del. لنقل أننا نريد إزالة العناصر octopus، و blobfish و mantis shrimp معًا. يمكننا فعل ذلك على النحو التالي:

sea_creatures =['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']

del sea_creatures[1:4]
print(sea_creatures)     #  ['shark', 'anemone', 'yeti crab']

باستخدام مجال مع العبارة del، تمكنا من إزالة العناصر الموجودة بين الفهرسَين 1 (مشمول) و 4 (غير مشمول)، والقائمة أضحت مكوّنة من 3 عناصر فقط بعد إزالة 3 عناصر منها.

بناء قوائم من قوائم أخرى موجودة

يمكن أن تتضمّن عناصر القوائم قوائم أخرى، مع إدراج كل قائمة بين قوسين معقوفين داخل الأقواس المعقوفة الخارجية التابعة لقائمة الأصلية:

sea_names = [['shark', 'octopus', 'squid', 'mantis shrimp'],['Sammy', 'Jesse', 'Drew', 'Jamie']]

تسمى القوائم المُتضمّنة داخل قوائم أخرى بالقوائم المتشعبة (nested lists).

للوصول إلى عنصر ضمن هذه القائمة، سيتعيّن علينا استخدام فهارس متعددة:

print(sea_names[1][0])    #  Sammy  
print(sea_names[0][0])    #  shark

فهرس القائمة الأولى يساوي 0، والقائمة الثانية فهرسُها 1. ضمن كل قائمة متشعبة داخلية، سيكون هناك فهارس منفصلة، والتي سنسميها فهارس ثانوية:

sea_names[0][0] = 'shark'
sea_names[0][1] = 'octopus'
sea_names[0][2] = 'squid'
sea_names[0][3] = 'mantis shrimp'

sea_names[1][0] = 'Sammy'
sea_names[1][1] = 'Jesse'
sea_names[1][2] = 'Drew'
sea_names[1][3] = 'Jamie'

عند العمل مع قوائم مؤلّفة من قوائم، من المهم أن تعي أنك ستحتاج إلى استخدام أكثر من فهرس واحد للوصول إلى عناصر القوائم المتشعبة.

خلاصة

القوائم هي نوع بيانات مرن يمكن تعديله بسهولة خلال أطوار البرنامج. غطينا في هذه المقالة الميزات والخصائص الأساسية لقوائم، بما في ذلك الفهرسة والاقتطاع والتعديل والضّم.

يمكنك تعلم المزيد عن القوائم من هاتين المقالتين:

• كيفية استخدام توابع القوائم في بايثون 3
• فهم كيفية استعمال List Comprehensions في بايثون 3

هذه المقالة جزء من سلسة مقالات حول تعلم البرمجة في بايثون 3.

ترجمة -وبتصرّف- للمقال Understanding Lists in Python 3 لصاحبته Lisa Tagliaferri

اقرأ أيضًا

• المقالة التالية: كيفية استخدام توابع القوائم في بايثون 3
• المقالة السابقة: فهم العمليات المنطقية في بايثون 3
• المرجع الشامل إلى تعلم لغة بايثون
• كتاب البرمجة بلغة بايثون

هناك قيمتان فقط لنوع البيانات المنطقية، وهما True و False. تُستخدم الحسابات المنطقية في البرمجة لإجراء الموازنات، والتحكم في مسار البرنامج.

تمثِّل القيم المنطقية قيم الحقيقة (truth values) في علم المنطق في الرياضيات. وتٌكتب القيمتان True و False دائمًا بالحرفين الكبيرين T و F على التوالي، لأنهما قيمتان خاصتان في بايثون.

في هذه المقالة، سنتعرف على العمليات المنطقية في بايثون، بما في ذلك الموازنة المنطقية، والعوامل المنطقية، وجداول الحقيقة.

عوامل الموازنة

في البرمجة، تُستخدم عوامل الموازنة للموازنة بين القيم، وتعيد إحدى القيمتين المنطقتين True و False.

يوضح الجدول أدناه عوامل الموازنة المنطقية.

لفهم كيفية عمل هذه العوامل، سنستخدم المتغيرين التاليين:

x = 5
y = 8

في هذا المثال، لمّا كان x يساوي 5، فهو أصغر من y ذي القيمة 8.

باستخدام هذين المتغيرين والقيم المرتبطة بهما، سنجرّب العوامل من الجدول أعلاه. سنطلب من بايثون أن تطبع ناتج عملية الموازنة، إما True أو False. لتوضيح المثال أكثر، سنطبع سلسلة نصية لتوضيح ما جرى تقييمه.

x = 5
y = 8

print("x == y:", x == y)
print("x != y:", x != y)
print("x < y:", x < y)
print("x > y:", x > y)
print("x <= y:", x <= y)
print("x >= y:", x >= y)

والمخرجات هي:

x == y: False
x != y: True
x < y: True
x > y: False
x <= y: True
x >= y: False

باتباع المنطق الرياضي، في كل من التعبيرات المذكورة أعلاه، هذه نتيجة الموازنات:

• 5 (x) تساوي 8 (y)؟ خطأ
• 5 تخالف 8؟ صح
• 5 أصغر من 8؟ صح
• 5 أكبر من 8؟ خطأ
• 5 أصغر من أو يساوي 8؟ صح
• 5 ليس أصغر من أو يساوي 8؟ خطأ

رغم أننا استخدمنا الأعداد الصحيحة هنا، إلا أنه بإمكاننا استبدال الأعداد العشرية بها.

يمكن أيضًا استخدام السلاسل النصية مع العوامل المنطقية. وهي حساسة لحالة الأحرف، ما لم تستخدم تابعًا إضافيًا للسلاسل النصية.

المثال التالي يوضح كيفية موازنة السلاسل النصية:

Sammy = "Sammy"
sammy = "sammy"

print("Sammy == sammy: ", Sammy == sammy)        # Sammy == sammy:  False

السلسلة "Sammy" أعلاه لا تساوي السلسلة النصية "sammy"، لأنهما ليستا متماثلتين تمامًا؛ فإحداهما تبدأ بحرف كبير S، والأخرى بحرف صغير s. ولكن لو أضفنا متغيرًا آخر قيمته "Sammy"، فستكونان متساويتين:

Sammy = "Sammy"
sammy = "sammy"
also_Sammy = "Sammy"

print("Sammy == sammy: ", Sammy == sammy)                   # Sammy == sammy:  False
print("Sammy == also_Sammy", Sammy == also_Sammy)   # Sammy == also_Sammy:  True

يمكنك أيضًا استخدام عوامل الموازنة الأخرى، بما في ذلك > و < لموازنة سلسلتين نصيتين. ستوازن بايثون هذه السلاسل النصية بحسب الترتيب المعجمي في نظام محارف ASCII.

يمكننا أيضًا تقييم القيم المنطقية باستخدام عوامل الموازنة:

t = True
f = False

print("t != f: ", t != f)      #   t != f:  True

تبيّن الشيفرة البرمجية أعلاه أنّ True لا تساوي False.

لاحظ الفرق بين العاملين = و ==.

x = y   # x إلى  y إسناد قيمة
x == y  # متساويين  x و  y تتحقق مما إذا كان

الأول =، هو عامل الإسناد (assignment operator)، والذي سيحدد قيمة أحد المتغيرين، ويجعلها مساوية لقيمة الآخر. الثاني ==، وهو عامل الموازنة الذي سيحدد ما إذا كانت القيمتان متساويتان.

دورة تطوير التطبيقات باستخدام لغة Python

احترف تطوير التطبيقات مع أكاديمية حسوب والتحق بسوق العمل فور انتهائك من الدورة

اشترك الآن

العوامل المنطقية

هناك ثلاثة عوامل منطقية تُستخدم لموازنة القيم. وتعيد إما True أو False. هذه العوامل هي، and (و)، و or (أو)، و not (النفي)، وقد عرّفناها في الجدول أدناه.

عادةً ما تُستخدم العوامل المنطقية لتقييم ما إذا كان تعبيران منطقيان صحيحان أم لا. على سبيل المثال، يمكن استخدامها لتحديد ما إذا كان الطالب قد نجح، وأنه مُسجل في الفصل، وإذا كانت كلتا الحالتان صحيحتان، فسيتم إدخال الطالب إلى النظام. مثال آخر هو تحديد ما إذا كان المستخدم عميلًا نشطًا لمتجر إلكتروني استنادًا إلى ما إذا كان لديه رصيد في المتجر، أو أنه اشترى خلال الأشهر الستة الماضية.

لفهم كيفية عمل العوامل المنطقية، دعنا نقيّم التعبيرات الثلاث التالية:

print((9 > 7) and (2 < 4))    # كلا التعبيرين صحيحان
print((8 == 8) or (6 != 6))   # أحد التعبيرين صحيح 
print(not(3 <= 1))             # التعبير الأصلي  خاطئ

والمخرجات هي:

True
True
True

في الحالة الأولى، ((9> 7) و (2 <4))print، كلا التعبيرين ‎9> 7 و ‎2 <4 ينبغي أن يكونا صحيحين لأنّ العامل and مُستخدَم.

في الحالة الثانية، print((8 == ? or (6 != 6))‎بما أنّ قيمة 8 == 8 تم تقييمها بـ True، فإنّ نتيجة تقييم ‎6 != 6‎لا تهم. لكن لو استخدمنا العامل and، لتمّ تقييم العبارة المنطقية بالقيمة False.

في الحالة الثالثة، print(not(3 <= 1))‎، العامل not ينفي القيمة False التي تعيدها العملية المنطقية 3 <= 1.

في المثال التالي سنستبدل بالأعداد العشرية أعدادًا صحيحة:

print((-0.2 > 1.4) and (0.8 < 3.1))    # أحد التعبيرين خاطئ 
print((7.5 == 8.9) or (9.2 != 9.2))     # كلا التعبيرين خاطئان
print(not(-5.7 <= 0.3))                  # التعبير الأصلي صحيح

في المثال أعلاه:

• and: يجب أن يكون واحد على الأقل من التعبيرين خاطئًا لتعيد القيمة False،
• or: يجب أن يكون كلا التعبيرين خاطئين لتعيد القيمة False،
• not: يجب أن يكون التعبير المرافق لها صحيحًا حتى تعيد القيمة False.

إذا لم تكن النتائج أعلاه واضحة لك، فسنعرض بعض جداول الحقيقة أدناه لتفهم الأمر بشكل أفضل.

يمكنك أيضًا كتابة عبارات مركبة باستخدام and, و or, و not:

not((-0.2 > 1.4) and ((0.8 < 3.1) or (0.1 == 0.1)))

التعبير الداخلي: (0.8 <3.1) أو (0.1 == 0.1). يعيد القيمة True، لأنّ كلا العبارتين الرياضيتين تعيدان True.

الآن، نأخذ القيمة المُعادة True ونجمعها مع التعبير المنطقي التالي: (‎-0.2> 1.4) and (True). هذا المثال يعيد False، لأنّ العبارة ‎-0.2> 1.4 تعيد القيمة False، و ‎(False) and (True)‎ تعيد False.

أخيرًا، يعيد التعبير الخارجي: not (False)‎ القيمة True، وبالتالي ستكون القيمة النهائية المعادة هي:

True

جداول الحقيقة (Truth Tables)

المنطق مجال واسع، وسنكتفي في هذه المقالة ببعض الأفكار المهمة التي يمكن أن تساعدك على تحسين طريقة تفكيرك وخوارزمياتك.

فيما يلي جداول الحقيقة لعامل الموازنة ==، والعوامل المنطقية and, و or, و not. من المفيد أن تحفظ كيفية عملها، فذلك سيجعلك أسرع في اتخاذ القرارات أثناء كتابة الشيفرات البرمجية.

جدول الحقيقة الخاص بالعامل ==

جدول الحقيقة الخاص بالعامل AND

جدول الحقيقة الخاص بالعامل OR

جدول الحقيقة الخاص بالعامل NOT

تُستخدم جداول الحقيقة في المنطق الرياضياتي كثيرًا، وهي مفيدة، ويجب حفظها ووضعها في الحسبان عند إنشاء الخوارزميات البرمجية.

استخدام العوامل المنطقية للتحكم في مسار البرنامج

للتحكم في مسار ونتائج البرنامج عبر العبارات الشرطية (flow control statements)، يمكننا استخدام شرط (condition) متبوعًا بعبارة برمجية (clause).

يتم تقييم الشرط بإحدى القيمتين True أو False، تلك القيمة تُستخدم لاتخاذ قرار في البرنامج. أما العبارة (clause) فهي الكتلة البرمجية التي تعقب الشرط وتحدِّد نتيجة البرنامج وما ينبغي فعله في حال تحقق الشرط.

تُظهر الشيفرة أدناه مثالًا على عوامل الموازنة التي تعمل مع العبارات الشرطية للتحكم في مسار البرنامج:

if grade >= 65:                 # شرط
    print("Passing grade")      # بند

else:
    print("Failing grade")

سيحدد هذا البرنامج ما إذا كان الطالب سينجح أم يرسب. في حال كانت الدرجة التي حصل عليها الطالب تساوي 83 مثلًا، فتقييم العبارة الأولى سيكون True، وسيُطبَع النص "Passing grade. أما إن كانت درجة الطالب هي 59، فتقييم العبارة الأولى سيكون False، وبالتالي سينتقل البرنامج لتنفيذ العبارة المرتبطة بالتعبير else، أي سيطبع Failing grade.

يمكن تقييم كل كائنات بايثون بإحدى القيمتين True أو False، لذلك يوصي الدليل PEP 8 بعدم موازنة كائن بإحدى القيمتين True أو False، لأنّ ذلك قد يؤدي إلى إعادة قيم منطقية غير متوقعة. على سبيل المثال، عليك تجنب استخدام مثل هذه العبارة sammy == True في برامجك.

تساعد العوامل المنطقية على صياغة شروط يمكن استخدامها لتحديد النتيجة النهائية للبرنامج من خلال التحكم في مسار التنفيذ.

خلاصة

ألقينا في هذه المقالة نظرة على الموازنات والعوامل المنطقية، بالإضافة إلى جداول الحقيقة، وكيفية استخدام القيم المنطقية للتحكم في مسار البرنامج.

هذه المقالة جزء من سلسة مقالات حول تعلم البرمجة في بايثون 3.

ترجمة -وبتصرّف- للمقال Understanding Boolean Logic in Python 3 لصاحبته Lisa Tagliaferri

اقرأ أيضًا

• المقالة التالية: مدخل إلى القوائم
• المقالة السابقة: الدوال الرياضية المضمّنة في بايثون 3
• المرجع الشامل إلى تعلم لغة بايثون
• كتاب البرمجة بلغة بايثون

تتضمّن بايثون 3 العديد من الدوال التي يمكنك استخدامها بسهولة في أي برنامج. تتيح لك بعض تلك الدوال تحويل أنواع البيانات، والبعض الآخر خاص بنوع معين، مثل السلاسل النصية.

سنستعرض في هذه المقالة بعض الدوال الرياضية المُضمّنة التي يمكن استخدامها مع أنواع البيانات العددية في بايثون 3. سنلقي نظرة على الدوال التالية:

• abs()‎: للحصول على القيمة المطلقة
• divmod()‎: للحصول على الحاصل والباقي في وقت واحد
• pow()‎: لرفع عدد لقوة معينة
• round()‎: لتقريب عدد بمنازل عشرية محددة
• sum()‎: لحساب مجموع العناصر في كائن قابلٍ للتكرار (iterable)

فهم هذه التوابع سيمنحك مرونة أكبر في البرمجة، ويساعدك على اتخاذ قرارات مدروسة عند تحديد العوامل والدوال التي عليك استخدامها. سنتطرق إلى بعض هذه الدوال في هذه المقالة، مع تقديم بعض الأمثلة.

القيمة المطلقة

تعيد الدالة المضمّنة abs()‎ القيمة المطلقة للعدد الذي يُمرر إليها. في الرياضيات، تشير القيمة المطلقة إلى العدد نفسه إن كانت القيمة موجبة، أو القيمة المعاكسة إن كانت القيمة سالبة.

مثلًا، القيمة المطلقة للعدد 15 هي 15، والقيمة المطلقة للعدد ‎-74 هي 74، والقيمة المطلقة للعدد 0 هي 0.

القيمة المطلقة مفهوم مهم في الحساب والتحليل، كما أنّها مفيدة كذلك في المواقف اليومية، مثل حساب المسافة المقطوعة. على سبيل المثال، إذا كنت تحاول الوصول إلى مكان يبعد 58 ميلًا، ولكنك تجاوزت ذلك المكان، وسافرت 93 فرسخًا. فإن حسبت عدد الفراسخ التي ينبغي أن تقطعها الآن للوصول إلى الوجهة المقصودة، فسوف ينتهي بك المطاف بعدد سالب، لكن لا يمكنك السفر عددًا سالبًا من الفراسخ!

سنستخدم الدالة abs()‎ لحل هذه المشكلة:

miles_from_origin = 58   # عدد الفراسخ التي تفصلنا عن الوجهة انطلاقًا من المُنطلق 
miles_travelled = 93       # الفراسخ المقطوعة من المُنطَلق إلى الوجهة

# حساب عدد الفراسخ من الموقع الحالي
miles_to_go = miles_from_origin - miles_travelled   

print(miles_to_go)            # طباعة عدد الفراسخ المتبقية - عدد سالب
print(abs(miles_to_go))    # حساب القيمة المطلقة للعدد السالب

المخرجات ستكون:

-35
35

لولا استخدام الدالة abs()‎، لحصلنا على عدد سالب، أي ‎-35. ورغم أنّ miles_travelled أصغر من miles_from_origin، فإنّ الدالة abs()‎ تحل إشكالية العدد السالب.

عندما نمرّر لها عددًا سالبًا، ستعيد الدالة abs()‎ عددًا موجبًا، لأنّ القيمة المطلقة دائمًا تعيد أعدادًا موجبة أو معدومة.

في المثال التالي، سنمرر للدالة abs()‎ عددًا موجبًا، وكذلك الصفر:

print(abs(89.9))     #  89.9 
print(abs(0))          # 0

العثور على الحاصل والباقي بدالة واحدة

القسمة التحتية (floor division، التي تُعيد حاصل القسمة [quotient])، وقسمة الباقي (modulo division، التي تعيد باقي القسمة [remainder])، مرتبطان ارتباطًا وثيقًا، وقد يكون من المفيد استخدام دالة تجمع بين العمليتين معًا.

تجمع الدالة المضمّنة divmod()‎ بين العمليتين، إذ تعيد أولًا حاصل عملية القسمة التحتية، ثم الباقي. ينبغي تمرير عددين إلى الدالة divmod()‎، على النحو التالي:

divmod(a,b)

تكافئ هذه الدالة العمليتين التاليتين:

a // b
a & b

لنفترض أننا كتبنا كتابًا يحتوي 80 ألف كلمة. يريد الناشر أن تحتوي كل صفحة من الكتاب ما بين 300 و 250 كلمة، ونود أن نعرف عدد الصفحات التي ستشكل الكتاب بحسب عدد كلمات الصفحة الذي اخترناه. باستخدام الدالة divmod()‎، يمكننا أن نعرف على الفور عدد الصفحات في الكتاب، وعدد الكلمات المتبقية التي ستُنقل إلى صفحة إضافية.

words = 80000     # كم عدد الكلمات في كتابنا
per_page_A = 300    # 300 عدد كلمات الصفحة هو :A الخيار
per_page_B = 250    # عدد كلمات الصفحة هو 250 :B الخيار 

print(divmod(words,per_page_A)) # A حساب الخيار
print(divmod(words,per_page_B)) # B حساب الخيار

وسينتج عن هذه الشيفرة:

(266, 200)
(320, 0)

في الخيار A، سنحصل على 266 صفحة مليئة بالكلمات، و 200 كلمة متبقية (ثلثا صفحة)، والمجموع هو 267 صفحة، وفي الخيار B، سنحصل على كتاب من 320 صفحة. إن أردنا الحفاظ على البيئة، فالخيار A قد يكون أفضل، ولكن إذا أردنا تصميمًا جذابًا، أو الكتابة بحجم خط كبير، فقد نختار الخيار "B".

تقبل الدالة divmod()‎ االأعداد الصحيحة والأعداد العشرية، في المثال التالي سنمرر عددًا عشريًّا إلى الدالة divmod()‎:

a = 985.5
b = 115.25

print(divmod(a,b))   #  (8.0, 63.5)

في هذا المثال، العدد 8.0 هو حاصل القسمة التحتية للعدد 985.5 مقسومًا على 115.25، و 63.5 هو الباقي.

يمكنك استخدام عامل القسمة التحتية // و عامل الباقي% للتحقق من نتيجة divmod()‎:

print(a//b)   #  8.0
print(a%b)   # 63.5

القوة (Power)

في بايثون، يمكنك استخدام عامل القوة ** (أو الأس) لرفع عدد إلى قوة معينة، أو يمكنك استخدام الدالة pow()‎ المضمّنة التي تأخذ عددين وتجري العملية نفسها.

لتوضيح كيفية عمل الدالة pow()‎، لنقل أننا نجري أبحاثًا على البكتيريا، ونريد أن نقدّر عدد البكتيريا التي سنحصل عليها في نهاية اليوم إذا بدأنا ببكتيريا واحدة. تتضاعف البكتيريا التي نعمل عليها في كل ساعة، لذلك النتيجة النهائية ستكون 2 قوة العدد الكلي لعدد الساعات التي مرت (24 في حالتنا).

hours = 24
total_bacteria = pow(2,hours)

print(total_bacteria)   # 16777216

لقد مرّرنا عددين صحيحين للدالة pow()‎، والنتيجة التي حصلنا عليها، والتي تمثِّل عدد البكتيريا بحلول نهاية اليوم، هي أكثر من 16 مليون بكتيريا.

في الرياضيات، نكتب "3 أسّ 3" بشكل عام على النحو التالي: 3^³ والتي تكافئ 3 × 3 × 3، أي 27. ولحساب 3^³ في بايثون، نكتب pow(3,3)‎. تقبل الدالة pow()‎ الأعداد الصحيحة والأعداد العشرية، وتوفّر بديلًا لعامل الأس **.

تقريب الأعداد

تقريب الأعداد (Rounding Numbers) ضروري عند العمل مع الأعداد العشرية التي تحتوي على الكثير من المنازل (الأجزاء) العشرية. تقبل الدالة المضمنة round()‎ عددين: أحدها يمثِّل العدد المراد تقريبه والآخر يحدّد عدد المنازل العشرية المراد الإبقاء عليها (أي قيمة التقريب).

سنستخدم هذه الدالة لتقريب عدد عشري له أكثر من 10 منازل عشرية والحصول على عدد بأربعة منازل عشرية فقط:

i = 17.34989436516001
print(round(i,4))   # 17.3499

في المثال أعلاه، تم تقريب العدد 17.34989436516001 إلى 17.3499 لأننا حددنا عدد المنازل العشرية التي ينبغي الاقتصار عليها بأربعة.

لاحظ أيضًا أنّ الدالة round()‎ تقرّب الأعداد إلى الأعلى، لذا بدلًا من إعادة 17.3498، فقد أعادت 17.3499، لأنّ الرقم الذي يلي المنزل العشري 8 هو الرقم 9. وسيتم تقريب أي عدد متبوع بالعدد 5 أو أكبر إلى العدد الصحيح التالي.

في الحياة اليومية، نُقرِّب الأعداد لأسباب كثيرة، وخاصة في التعاملات المالية؛ فلا يمكننا تقسيم فلس واحد بالتساوي بين عدة أصدقاء مثلًا.

سنكتب في المثال التالي برنامجًا بسيطًا يمكنه حساب البقشيش. في هذا المثال سنحدد قيم المتغيرات، ولكن يمكنك إعادة كتابة البرنامج لجعل المستخدمين يدخلون القيم. في هذا المثال، ذهب 3 أصدقاء إلى مطعم، وأرادوا تقسيم الفاتورة، والتي تبلغ 87.93 دولارًا بالتساوي، بالإضافة إلى إكرامية (بقشيش) بنسبة 20٪.

bill = 87.93                   # إجمالي الفاتورة
tip = 0.2                      # ٪ 20 بقشيش
split = 3                      # عدد الناس الذين سيتشاركون الفاتورة

total = bill + (bill * tip)    # حساب الفاتورة الإجمالية
each_pay = total / split       # حساب ما ينبغي أن يدفعه كل شخص
print(each_pay)                # ما ينبغي أن يدفعه كل شخص قبل التقريب
print(round(each_pay,2))       # تقريب العدد - لا يمكننا تقسيم الفلسات

والمخرجات ستكون:

35.172000000000004
35.17

في هذا البرنامج، نطلب أولًا إخراج العدد بعد حساب إجمالي الفاتورة والإكراميات مقسومًا على 3، النتيجة ستكون عددًا يتضمّن الكثير من المنازل العشرية: 35.172000000000004. نظرًا لأنّ هذا العدد ليس له معنى كمبلغ مالي، فإننا نستخدم الدالة round()‎، ونقصر المنازل العشرية على 2، حتى نتمكن من توفير ناتج يمكن للأصدقاء الثلاثة أن يدفعوه: 35.17.

إذا كنت تفضل التقريب إلى عدد بلا منازل عشرية، يمكنك تمرير 0 كمعامل ثان إلى الدالة round()‎:

round(345.9874590348545304636,0)

القيمة الناتجة ستكون 346.0.

يمكنك أيضًا تمرير الأعداد الصحيحة إلى round()‎ دون الخوف من تلقي خطأ، وهذا مفيد في حال تلقيت من المستخدم عددًا صحيحًا بدلًا من عدد عشري. وفي هذه الحالة، سيُعاد عدد صحيح.

حساب المجموع

تُستخدم الدالة sum()‎ لحساب مجاميع أنواع البيانات العددية المركبة (numeric compound data types)، بما في ذلك القوائم، والصفوف، والقواميس.

يمكننا تمرير قائمة إلى الدالة sum()‎ لجمع كل عناصرها بالترتيب من اليسار إلى اليمين:

some_floats = [1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9]
print(sum(some_floats))    #  49.5

نفس النتيجة سنحصل عليها إن استخدمنا الصفوف والقواميس:

print(sum((8,16,64,512)))  # حساب مجموع الأعداد في الصف
print(sum({-10: 'x', -20: 'y', -30: 'z'}))  # حساب مجموع الأعداد في القاموس

المخرجات:

60
-60

يمكن أن تأخذ الدالة sum()‎ وسيطين، الوسيط الثاني سيُضاف إلى المجموع الناتج:

some_floats = [1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9]

print(sum(some_floats, 0.5))                     # 50.0
print(sum({-10: 'x', -20: 'y', -30: 'z'},60))    # 0

القيمة الافتراضية للوسيط الثاني هي 0.

خلاصة

غطينا في هذه المقالة بعض التوابع المضمّنة التي يمكنك استخدامها مع أنواع البيانات العددية في بايثون.

هذه المقالة جزء من سلسة مقالات حول تعلم البرمجة في بايثون 3.

ترجمة -وبتصرّف- للمقال Built-in Python 3 Functions for Working with Numbers لصاحبته Lisa Tagliaferri

اقرأ أيضًا

• المقالة التالية: فهم العمليات المنطقية في بايثون 3
• المقالة السابقة: كيفية إجراء العمليات الحسابية في بايثون 3
• المرجع الشامل إلى تعلم لغة بايثون
• كتاب البرمجة بلغة بايثون

الأعداد شائعةٌ جدًا في البرمجة، إذ تُستخدم لتمثيل مختلف القيم، مثل أبعاد حجم الشاشة، والمواقع الجغرافية، والمبالغ المالية، ومقدار الوقت الذي مر منذ بداية فيديو، والألوان وغير ذلك.

تعد القدرة على تنفيذ العمليات الرياضية بفعالية في البرمجة مهارة مهمة، لأنّك ستعمل على الأعداد كثيرًا. الفهم الجيد للرياضيات يمكن أن يساعدك على أن تصبح مبرمجًا أفضل، إلا أنه ليس شرطًا أساسيًا. فالرياضيات أداة لتحقيق ما ترغب في تحقيقه، وطريقة لتحسين خططك.

سنعمل مع أكثر نوعي البيانات استخدامًا في بايثون، وهما الأعداد الصحيحة والأعداد العشرية:

• الأعداد الصحيحة هي أعداد كاملة يمكن أن تكون موجبة أو سالبة أو معدومة (...، ‎-1، 0، 1، ...).
• الأعداد العشرية هي أعداد حقيقية تحتوي على فاصلة عشرية (كما في 9.0 أو ‎-2.25).

سنلقي في هذه المقالة نظرة على العوامل (operators) التي يمكن استخدامها مع أنواع البيانات العددية في بايثون.

العوامل

العامل (operator) هو رمز أو دالة تمثل عملية حسابية. على سبيل المثال، في الرياضيات، علامة الجمع أو + هي العامل الذي يشير إلى عملية الجمع.

في بايثون، سنرى بعض العوامل المألوفة، والتي استُعيرَت من الرياضيات، لكن هناك عوامل أخرى خاصة بمجال البرمجة.

الجدول التالي مرجعٌ سريعٌ للعوامل الحسابية في بايثون. سنغطي جميع هذه العمليات في مقالتنا هذه.

سنتحدث أيضًا عن عوامل الإسناد المركبة (compound assignment operators)، بما في ذلك ‎+=‎ و ‎*=‎، التي تجمع عاملًا حسابيًا مع العامل =.

الجمع والطرح

في بايثون، يعمل عاملا الجمع والطرح كما هو معروف في الرياضيات. في الواقع، يمكنك استخدام لغة بايثون آلةً حاسبةً.

لنلقِ نظرة على بعض الأمثلة، بدءًا من الأعداد الصحيحة:

print(1 + 5)

والناتج:

6

بدلًا من تمرير أعداد صحيحة مباشرة إلى الدالة print، يمكننا تهيئة المتغيرات بأعداد صحيحة:

a = 88
b = 103

print(a + b)

وسينتج لنا:

191

الأعداد الصحيحة يمكن أن تكون موجبة أو سالبة (أو معدومة أيضًا)، لذلك يمكننا إضافة عدد سالب إلى عدد موجب:

c = -36
d = 25

print(c + d)  #  -11

الجمع سيكون مشابهًا مع الأعداد العشرية:

e = 5.5
f = 2.5

print(e + f)   #  8.0

إذا جمعنا عددين عشريين معًا، ستعيد بايثون عددًا عشريًّا.

صياغة الطرح تشبه صياغة الجمع، ما عدا أنك ستستبدل بعامل الطرح (-) عامل الجمع (+?

g = 75.67
h = 32

print(g - h)    #  43.67

هنا، طرحنا عددًا صحيحًا من عدد عشري. ستعيد بايثون عددًا عشريًّا إذا كان أحد الأعداد المتضمنة في المعادلة عشريًّا.

دورة تطوير التطبيقات باستخدام لغة Python

احترف تطوير التطبيقات مع أكاديمية حسوب والتحق بسوق العمل فور انتهائك من الدورة

اشترك الآن

العمليات الحسابية الأحادية

يتكون التعبير الرياضي الأحادي (unary mathematical expression) من مكوّن أو عنصر واحد فقط، ويمكن في بايثون استخدام العلامتين + و - بمفردهما عبر اقترانهما بقيمة لإعادة القيمة نفسها (+)، أو تغيير إشارة القيمة (-) .

رغم أنها لا تُستخدم كثيرًا، تشير علامة الجمع إلى هوية القيمة (identity of the value)، أي تعيد القيمة نفسها. يمكننا استخدام علامة الجمع مع القيم الموجبة:

i = 3.3
print(+i)   #  3.3

عندما نستخدم علامة الجمع مع قيمة سالبة، فستُعيد القيمة نفسها، وفي هذه الحالة ستكون قيمة سالبة:

j = -19
print(+j)    #  -19

عند استخدامها مع قيمة سالبة، ستعيد علامة الجمع القيمة السالبة نفسها.

علامة الطرح، على خلاف علامة الجمع، تغيّر إشارة القيمة. لذلك، عندما نضعها مع قيمة موجبة، ستُعاد القيمة السالبة منها:

i = 3.3
print(-i)   #  -3.3

بالمقابل، عندما نستخدم عامل الطرح الأحادي (minus sign unary operator) مع قيمة سالبة، فستُعاد القيمة الموجبة منها:

j = -19
print(-j)   # 19

ستُعيِد العمليتان الحسابيتان الأحاديتان + و - إمَّا هوية القيمة المعطاة، أو القيمة المعاكسة في الإشارة للقيمة المعطاة على التوالي.

الضرب والقسمة

مثل الجمع والطرح، الضرب والقسمة في بايثون مشابهان لما هو معروف في الرياضيات. علامة الضرب في بايثون هي *، وعلامة القسمة هي /.

فيما يلي مثال على ضرب عددين عشريين في بايثون:

k = 100.1
l = 10.1

print(k * l)   #  1011.0099999999999

عندما تُجري عملية القسمة في بايثون 3، فسيكون العدد المُعاد دائمًا عشريًّا، حتى لو استخدمت عددين صحيحين:

m = 80
n = 5

print(m / n)   #  16.0

هذا أحد الاختلافات الرئيسية بين بايثون 2 و بايثون 3. الإجابة في بايثون 3 تكون كسرية، فعند استخدام / لتقسيم 11 على 2 مثلًا، فستُعاد القيمة 5.5. أمَّا في بايثون 2، فحاصل التعبير 11/2 هو 5.

يُجرِي العامل / في بايثون 2 قسمة تحتية (floor division)، إذ أنّه إن كان حاصل القسمة يساوي x، فسيكون ناتج عملية القسمة في بايثون 2 أكبر عدد من الأعداد الصحيحة الأصغر من أو تساوي x. إذا نفَّذت المثال print(80 / 5)‎ أعلاه في بايثون 2 بدلًا من بايثون 3، فسيكون الناتج هو 16، وبدون الجزء العشري.

في بايثون 3، يمكنك استخدام العامل // لإجراء القسمة التحتية. التعبير ‎100 // 40‎ سيعيد القيمة 2. القسمة التحتية مفيدة في حال كنت تريد أن يكون حاصل القسمة عددًا صحيحًا.

معامل باقي القسمة (Modulo)

العامل % هو عامل الباقي (modulo)، والذي يُرجع باقي عملية القسمة. هذا مفيد للعثور على الأعداد التي هي مضاعفات لنفس العدد، على سبيل المثال.

المثال التالي يوضح كيفية استخدام عامل الباقي:

o = 85
p = 15

print(o % p)   #  10

حاصل قسمة 85 على 15 هو 5، والباقي 10. القيمة 10 هي التي ستُعاد هنا لأنَّ عامل الباقي يعيد باقي عملية القسمة.

إذا استخدمنا عددين عشريين مع عامل الباقي، فسيُعاد عدد عشري:

q = 36.0
r = 6.0

print(o % p)    #  0.0

في حال قسمة 36.0 على 6.0، فلن يكون هناك باقٍ، لذلك تعاد القيمة 0.0.

القوة (Power)

يُستخدم عامل القوة ** (يقال له أحيًانًا «الأس») في بايثون لرفع العدد على اليسار لقوة الأس على اليمين. وهذا يعني أنه في التعبير 5 ** 3، العدد 5 سيُرفع إلى القوة 3. في الرياضيات، غالبًا ما نرى هذا التعبير يُكتب على الشكل 5^³، حيث يُضرب العدد 5 في نفسه 3 مرات. في بايثون، التعبيران 5 ** 3 و 5 * 5 * 5 سيعطيان النتيجة نفسها.

سنستخدم في المثال التالي المتغيرات:

s = 52.25
t = 7

print(s ** t)     #  1063173305051.292

رفع العدد العشري 52.25 إلى القوة 7 عبر عامل الأسّ ** سينتج عنه عدد عشري كبير.

أسبقية العوامل

في بايثون، كما هو الحال في الرياضيات، علينا أن نضع في حساباتنا أنَّ العوامل ستُقيَّم وفقًا لنظام الأسبقية، وليس من اليسار إلى اليمين، أو من اليمين إلى اليسار.

إذا نظرنا إلى التعبير التالي:

u = 10 + 10 * 5

قد نقرأه من اليسار إلى اليمين، ولكن تذكّر أنّ عملية الضرب ستُجرى أولًا، لذا إن استدعينا print(u)‎، فسنحصل على القيمة التالية:

60

هذا لأنّ 10 * 5 ستُقيّم أولًا، وسينتج عنها العدد 50، ثم نضيف إليها 10 لنحصل على 60 كنتيجة نهائية.

إذا أردنا بدلًا من ذلك إضافة القيمة 10 إلى 10، ثم ضرب المجموع في 5، فيمكننا استخدام الأقواس كما نفعل في الرياضيات:

u = (10 + 10) * 5
print(u)    #  100

إحدى الطرق البسيطة لتذكر الأسبقيات هي حفظ الجملتين «قم أبعد ضيقًا ... قم جد طريقًا» لتذكر أوائل كلماتهما:

ملاحظة: انتبه إلى أن الضرب ليس بالضرورة قبل القسمة كما هو مذكور في الجدول، بل أيهما أسبق بالمعادلة (في حال لم تكن هنالك أية أقواس)، فإن جاءت عملية القسمة قبل الضرب، فستُنفَّذ أولًا وفقًا لذلك الترتيب (ترتيب التنفيذ من اليسار إلى اليمين)، وكذلك الأمر بالنسبة لعملية الجمع والطرح، فليس الجمع دائما قبل الطرح، بل أيهما أسبق.

u = (10 / 5 * 2) - 3 + 4
print(u)    #  5

عامل الإسناد (Assignment Operators)

أكثر عوامل الإسناد استخدامًا هو إشارة التساوي =. يُسنِد عامل الإسناد (أو عامل التعيين) = القيمة الموجودة على اليمين إلى المتغير الموضوع على اليسار. على سبيل المثال، يُسنِد التعبير v = 23 العدد الصحيح 23 للمتغير v.

من الشائع استخدام عوامل الإسناد المركبة التي تجري عملية رياضية على قيمة المتغير، ثم تُسنِد القيمة الجديدة الناتجة إلى ذلك المتغير. تجمع عوامل الإسناد المركبة بين عامل رياضي والعامل =؛ ففي حال الجمع، نستخدم + مع = للحصول على عامل الإسناد المركب ‎+=‎. لنطبِّق ذلك في مثال عملي:

w = 5
w += 1
print(w)   #  6

أولاً، نعيّن المتغير ‎w إلى القيمة 5، ثم نستخدم عامل الإسناد المركب ‎+=‎ لإضافة العدد الصحيح إلى قيمة المتغير الأيسر، ثم نُسنِد النتيجة إلى المتغير w.

تُستخدم عوامل الإسناد المركبة بشكل متكرر مع حلقات for التكرارية، والتي ستستخدمها عندما تريد تكرار عمليةٍ عدة مرات:

for x in range (0, 7):
    x *= 2
    print(x)

والناتج سيكون:

0
2
4
6
8
10
12

باستخدام الحلقة for، تمكنا من أتمتة العملية ‎*=‎ التي تضرب قيمة المتغير w بالعدد 2، ثم تُسنِد النتيجة إلى المتغير w لأجل استخدامها في التكرار التالي في الحلقة.

لدى بايثون عامل إسناد مركب مقابل لكل من العوامل الحسابية التي تم التطرق إليها في هذه المقالة:

y += 1     # إضافة القيمة ثم إسنادها
y -= 1     # طرح القيمة ثم إسنادها
y *= 2      # ضرب القيمة ثم إسنادها
y /= 3      # تقسيم القيمة ثم إسنادها
y // = 5    # تقسيم سفلي القيمة ثم إسنادها
y **= 2     # تنفيذ عامل الأس على القيمة ثم إسنادها
y %= 3     # إعادة باقي قسمة القيمة ثم إسناده

يمكن أن يكون عامل الإسناد المركب مفيدًا عندما تحتاج إلى الزيادة أو الإنقاص التدريجي، أو عندما تحتاج إلى أتمتة عمليات معينة في برنامجك.

خلاصة

غطّينا في هذه المقالة العديد من العوامل التي ستستخدمها مع الأعداد الصحيحة والعشرية. يمكنك قراءة المزيد عن الأعداد في المقالة: الدوال العددية المضمّنة في بايثون 3.

لمعرفة المزيد حول أنواع البيانات الأخرى، ألق نظرة على المقالة: فهم أنواع البيانات في بايثون 3، وتعرف على كيفية تحويل أنواع البيانات في المقالة: كيفية تحويل أنواع البيانات في بايثون 3.

هذه المقالة جزء من سلسة مقالات حول تعلم البرمجة في بايثون 3.

ترجمة -وبتصرّف- للمقال How To Do Math in Python 3 with Operators لصاحبته Lisa Tagliaferri

اقرأ أيضًا

• المقالة التالية: الدوال الرياضية المضمّنة في بايثون 3
• المقالة السابقة: كيفية استخدام آلية تنسيق السلاسل النصية
• صفحة: تعلم بايثون
• المرجع الشامل إلى تعلم لغة بايثون
• كتاب البرمجة بلغة بايثون

الدالة str.format()‎ المتوافرة للسلاسل النصية تسمح لك باستبدال المتغيرات وتنسيق القيم. مما يمنحك القدرة على تجميع العناصر مع بعضها عبر إدخالها في مواضع معينة.
سيشرح لك هذا الدرس أشهر الاستخدامات لآلية تنسيق السلاسل النصية في بايثون، والتي ستساعدك في جعل شيفرتك وبرنامجك أسهل قراءةً واستخدامًا.

استخدام «المُنسِّقات»

تعمل المُنسِّقات (formatters) بوضع حقول قابلة للاستبدال تُعرَّف عبر وضع قوسين معقوفين {} في السلسلة النصية ثم استدعاء الدالة str.format()‎، إذ ستُمرَّر القيمة التي تريد وضعها ضمن السلسلة النصية إلى الدالة format()‎ وستوضع هذه القيمة في نفس مكان الحقل القابل للاستبدال الموجود في السلسلة الأصلية عندما تُشغِّل برنامجك.
لنطبع سلسلةً نصيةً تستخدم «مُنسِّقًا» (formatter):

print("Sammy has {} balloons.".format(5))

الناتج:

Sammy has 5 balloons.

أنشأنا في المثال السابق سلسلةً نصيةً تحتوي على قوسين معقوفين:

"Sammy has {} balloons."

ثم أضفنا الدالة str.format()‎ ومررنا إليها القيمة الرقمية 5 وهذا يعني أنَّ القيمة 5 ستوضع مكان القوسين المعقوفين:

Sammy has 5 balloons.

يمكننا أيضًا إسناد السلسلة النصية الأصلية التي تحتوي مُنسِّقًا إلى متغير:

open_string = "Sammy loves {}."
print(open_string.format("open source"))

الناتج:

Sammy loves open source.

أضفنا في المثال السابق السلسلة النصية "open source" إلى سلسلةٍ نصيةٍ أكبر باستبدالها للقوسين المعقوفين الموجودَين في السلسلة الأصلية.
تسمح لك المُنسِّقات في بايثون باستخدام الأقواس المعقوفة لحجز أماكن للقيم التي ستمررها مستقبلًا عبر الدالة str.format()‎.

استخدام المُنسِّقات لحجز أكثر من مكان

يمكنك استخدام أكثر من زوج من الأقواس المعقوفة عند استعمال المُنسِّقات؛ فيمكنك أن تضيف سلسلةً نصيةً أخرى إلى المثال السابق وذلك بإضافة زوج آخر من الأقواس المعقوفة وتمرير قيمة ثانية إلى الدالة كما يلي:

new_open_string = "Sammy loves {} {}."                      # {} مكانين محجوزين عبر
print(new_open_string.format("open-source", "software"))    # تمرير قيمتين إلى الدالة مفصولٌ بينهما بفاصلة

الناتج:

Sammy loves open-source software.

أضفنا زوجًا آخر من الأقواس المعقوفة إلى السلسلة النصية للسماح بوضع قيمة ثانية، ثم مررنا سلسلتين نصيتين إلى الدالة str.format()‎ مفصولٌ بينهما بفاصلة.
سنضيف عمليات استبدال أخرى عبر اتباع نفس الآلية التي شرحناها أعلاه:

sammy_string = "Sammy loves {} {}, and has {} {}."                      
print(sammy_string.format("open-source", "software", 5, "balloons"))

الناتج:

Sammy loves open-source software, and has 5 balloons.

إعادة ترتيب المنسقات عبر المعاملات الموضعية

عندما نترك الأقواس المعقوفة دون معاملات (parameters) ممررة إليها، فستضع بايثون القيم المُمرَّرة إلى الدالة str.format()‎ بالترتيب. هذا تعبيرٌ فيه زوجين من الأقواس المعقوفة يوضع مكانهما سلسلتان نصيتان شبيهٌ بما رأيناه سابقًا في هذا الدرس:

print("Sammy the {} has a pet {}!".format("shark", "pilot fish"))

الناتج:

Sammy the shark has a pet pilot fish!

اُستبدِل أوّل زوجٍ من الأقواس المعقوفة ووضعت مكانه القيمة "shark"، ووضعت القيمة "pilot fish" مكان الزوج الثاني من الأقواس.
القيم التي مررناها إلى الدالة str.format()‎ كانت بهذا الترتيب:

("shark", "pilot fish")

إن سبق لك دراسة أنواع البيانات المُختلفة على بايثون فقد تلاحظ أنَّ القيمة السابقة هي من النوع tuple، ويمكن الوصول إلى كل قيمة موجودة فيها عبر فهرسٍ رقميٍ تابعٍ لها، والذي يبدأ من الفهرس 0.
يمكننا تمرير أرقام الفهارس إلى داخل القوسين المعقوفين:

print("Sammy the {0} has a pet {1}!".format("shark", "pilot fish"))

سنحصل بعد تنفيذ المثال السابق على نفس الناتج التي ظهر دون تحديد أرقام الفهارس يدويًا، وذلك لأننا استدعينا القيم بالترتيب:

Sammy the shark has a pet pilot fish!

لكن إن عكسنا أرقام الفهارس في معاملات الأقواس المعقوفة فسنتمكن من عكس ترتيب القيم المُمرَّرة إلى السلسلة النصية الأصلية:

print("Sammy the {1} has a pet {0}!".format("shark", "pilot fish"))

الناتج:

Sammy the pilot fish has a pet shark!

لكن إن حاولت استخدام الفهرس ذي الرقم 2 ولم تكن لديك إلا قيمتين موجودتين في الفهرسين 0 و 1، فأنت تستدعي قيمةً خارج المجال المسموح، ولهذا السبب ستظهر رسالة خطأ:

print("Sammy the {2} has a pet {1}!".format("shark", "pilot fish"))

الناتج:

IndexError: tuple index out of range

تُشير رسالة الخطأ إلى وجود قيمتين فقط ومكانهما هو 0 و1، لذا كان الفهرس 2 غير مرتبطٍ بقيمةٍ وكان خارج المجال المسموح.
لنضف الآن مكانين محجوزين إلى السلسلة النصية ولنمرر بضع قيم إلى الدالة str.format()‎ لكي نفهم آلية إعادة الترتيب فهمًا تامًا. هذه هي السلسلة النصية الجديدة التي فيها أربعة أزواج من الأقواس المعقوفة:

print("Sammy is a {}, {}, and {} {}!".format("happy", "smiling", "blue", "shark"))

الناتج:

Sammy is a happy, smiling and blue shark!

ستوضع القيم المُمرَّرة إلى الدالة str.format()‎ بنفس ترتيب ورودها في حال لم نستعمل المعاملات داخل الأقواس المعقوفة.
تملك السلاسل النصية المُمرَّرة إلى الدالة str.format()‎ الفهارس الآتية المرتبطة بها:

لنستخدم الآن أرقام الفهارس لتغيير ترتيب ظهور القيم المرتبطة بها في السلسلة النصية:

print("Sammy is a {3}, {2}, and {1} {0}!".format("happy", "smiling", "blue", "shark"))

الناتج:

Sammy is a shark, blue, and smiling happy!

ولمّا كنّا قد بدأنا بالفهرس ذي الرقم 3، فستظهر القيمة "shark" أولًا. أي أنَّ وضع رقم الفهرس بين القوسين كمعامل سيؤدي إلى تغيير ترتيب ظهور القيم في السلسلة النصية الأصلية.
نستطيع -بالإضافة إلى المعاملات الموضعية الرقمية- أن نربط بين القيم وبين كلمات محجوزة مخصصة ومن ثم نستدعيها عبر وضع الكلمة المحجوزة بين القوسين المعقوفين كما يلي:

print("Sammy the {0} {1} a {pr}.".format("shark", "made", pr = "pull request"))

الناتج:

Sammy the shark made a pull request.

أظهر المثال السابق استخدام كلمة محجوزة كوسيط بالإضافة إلى المعاملات الموضعية، يمكنك استخدام الكلمة المحجوزة pr كوسيط بالإضافة إلى أرقام الفهارس، وتستطيع أيضًا إعادة ترتيب تلك الوسائط كيفما شئت:

print("Sammy the {pr} {1} a {0}.".format("shark", "made", pr = "pull request"))

الناتج:

Sammy the pull request made a shark.

استخدام المعاملات الموضعية والكلمات المحجوزة سيمنحنا تحكمًا أكبر بكيفية معالجة السلسلة النصية الأصلية عبر إعادة ترتيب القيم المُمرَّرة إليها.

تحديد نوع القيمة

يمكنك وضع معاملات أخرى ضمن القوسين المعقوفين، سنستخدم الصيغة الآتية {field_name:conversion} حيث field_name هو الفهرس الرقمي للوسيط الممرَّر إلى الدالة str.format()‎ والذي شرحناه تفصيليًا في القسم السابق، و conversion هو الرمز المستعمل للتحويل إلى نوع البيانات الذي تريده.
«رمز التحويل» يعني رمزًا من حرفٍ وحيد الذي تستخدمه بايثون لمعرفة نوع القيمة المُراد «تنسيقها». الرموز التي سنستخدمها في أمثلتنا هي s للسلاسل النصية و d لإظهار الأرقام بنظام العد العشري (ذي الأساس 10) و f لإظهار الأعداد ذات الفاصلة. يمكنك قراءة المزيد من التفاصيل عن رموز التنسيق في بايثون 3 (وغير ذلك من المواضيع المرتبطة بهذا المجال) في التوثيق الرسمي.
لننظر إلى مثالٍ نُمرِّر فيه رقمًا صحيحًا عبر الدالة format()‎ لكننا نريد إظهاره كعددٍ ذي فاصلة عبر رمز التحويل f:

print("Sammy ate {0:f} percent of a {1}!".format(75, "pizza"))