شرحنا في المقال السابق كيفية بناء لعبة نرد بسيطة باستعمال لغة بايثون، وتعرفنا على وحدة السلحفاة Turtle الخاصة برسم الخطوط والأشكال البسيطة.

وسنعرض في هذا المقال وحدة أخرى لكنها متقدمة ومتخصصة بالألعاب الرسومية كما يشير اسمها فهي تدعى PyGame، هذه الوحدة ليست مضمنة افتراضيًا في بايثون مثل وحدة السلحفاة، لذا عليك تنزيلها وتثبيتها بنفسك فلها مكتبةٌ خاصة.

يمكنك مطالعة المقالات ضمن السلسلة:

1. بناء لعبة نرد بسيطة بلغة بايثون.
2. بناء لعبة رسومية باستخدام بايثون ووحدة الألعاب PyGame.
3. إضافة لاعب إلى اللعبة المطورة باستخدام بايثون و Pygame.
4. تحريك شخصية اللعبة باستخدام PyGame.
5. إضافة شخصية العدو للعبة.
6. إضافة المنصات إلى لعبة بايثون باستخدام الوحدة Pygame.
7. محاكاة أثر الجاذبية في لعبة بايثون.
8. إضافة خاصية القفز والركض إلى لعبة بايثون.
9. إضافة الجوائز إلى اللعبة المطورة بلغة بايثون.
10. تسجيل نتائج اللعبة المطورة بلغة بايثون وعرضها على الشاشة.
11. إضافة آليات القذف إلى اللعبة المطورة بلغة بايثون.

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

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

مكتبة Pygame

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

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

• تعيين لون للخلفية.
• تعيين صورة للخلفية.

وفي الحالتين لن تتفاعل شخصيات اللعبة مع الخلفية سواء أكانت صورة أو لون فهي مجرد بيئة جامدة للعبتك.

كيفية استعمال Pygame

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

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

ولا تنسَ تفعيل خيار بناء البيئة الافتراضية باستخدام Virtualenv وخيار إنشاء الملف main.py مع الإبقاء على الخيارات الأخرى كما هي افتراضيًا.

اضغط الآن على زر إنشاء ليظهر مشروعك الجديد في نافذة PyCharm وهو يتألف من بيئة افتراضية env (تجدها في العمود اليساري) وملف نموذجي main.py.

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

#!/usr/bin/env python3
# by Seth Kenlon

## GPLv3
# This program is free software: you can redistribute it and/or
# modify it under the terms of the GNU General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

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

import pygame  # ‫لاستيراد الوحدة pygame
import sys    # تسمح لبايثون باستخدام نظام التشغيل
import os    # لمساعدة بايثون في التعرف على نظام تشغيلك والتكيف معه

ستلاحظ أن PyCharm يميز الكلمة pygame عن كل من os و sys ويعدّها خطأ، فهو لم يتعرف على هذه الوحدة بعد، إذ إنها غير مضمنة افتراضيًا مع بايثون كما ذكرنا في المقدمة، لذا ينبغي علينا تثبيتها قبل استخدامها.

لتثبيتها يكفي أن تمرر مؤشر الفأرة فوق الكلمة وستظهر لك نافذة منبثقة تُطالبك بتثبيت الحزمة، انقر على رابط التثبيت وانتظر انتهاء العملية وستصبح Pygame جاهزة في بيئتك الافتراضية.

أما لو أردت تثبيتها يدويًا بدون بيئة التطوير المتكاملة فاستخدم الأمر pip.

تقسيم شيفرة اللعبة

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

'''
Variables
'''

# ضع المتغيرات في هذا المقطع 


'''
Objects
'''

# ضع هنا أصناف ودوال بايثون


'''
Setup
'''

# ضع كود التشغيل-لمرة-واحدة 


'''
Main Loop
'''

# ضع هنا الحلقة الرئيسية للعبة 

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

'''
Variables
'''
worldx = 960
worldy = 720

لننتقل للإعدادات الخاصة بمحرك Pygame، وتتمثل في ضبط معدل الأطر frame rate والساعة الداخلية internal clock (باستخدام الكلمة المفتاحية init).

اكتب أولًا المتغيرات التالية في المقطع المخصص للمتغيرات:

fps   = 40  # معدل الأطر
ani   = 4   # دورات الحركة

والآن التعليمات الخاصة بالساعة الداخلية ضمن مقطع الإعدادات:

'''
Setup
'''

clock = pygame.time.Clock()
pygame.init()

ضبط الخلفية

اختر صورة مناسبة للعبتك أو صممها بأحد برامج التصميم الجرافيكي واحفظها باسم stage.png في المجلد images ضمن مجلد مشروعك.

إليك بعض برامج التصميم المجانية التي يمكنك استخدامها على سبيل المثال لا الحصر:

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

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

والآن بعد أن جهزت الصورة اكتب التعليمات التالية ضمن مقطع الإعدادات:

world = pygame.display.set_mode([worldx,worldy])
backdrop = pygame.image.load(os.path.join('images','stage.png'))
backdropbox = world.get_rect()

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

world = pygame.display.set_mode([worldx, worldy])

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

'''
Variables
'''

BLUE  = (25, 25, 200)
BLACK = (23, 23, 23)
WHITE = (254, 254, 254)

اكتشاف الأخطاء

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

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

أما الأخطاء ينبغي عليك تصحيحها بالتأكيد لأنها تعطل تنفيذ البرنامج، فعلى سبيل المثال تشدد PyCharm على وجود ما يدل على إدخال سطر جديد في نهاية السطر الأخير من الكود، لذا عليك الضغط على زر Enter أو Return في لوحة المفاتيح في نهاية الكود حتى يعمل.

تشغيل اللعبة

احفظ التغييرات وشغل اللعبة، عبر الضغط على زر "تشغيل الوحدة Run Module" من قائمة تشغيل في IDLE أو الضغط على "تشغيل ملف Run file" من شريط الأدوات في PyCharm.

ويمكنك أيضًا التشغيل باستخدام نافذة الطرفية في يونيكس أو موجه سطر الأوامر في ويندوز بشرط أن تقوم بذلك وأنت في البيئة الافتراضية لبايثون.

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

حلقة التكرار

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

إذًا اكتب التعليمات التالية في برنامجك ضمن المقطع الخاص بالحلقة الرئيسية:

'''
Main loop
'''

while main:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            try:
                sys.exit()
            finally:
                main = False

        if event.type == pygame.KEYDOWN:
            if event.key == ord('q'):
                pygame.quit()
            try:
                sys.exit()
            finally:
                main = False

ولا تنسَ الضغط على زر Enter أو Return في نهاية السطر الأخير، ليُضاف سطر فارغ في نهاية ملف البرنامج.

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

world.blit(backdrop, backdropbox)

أو التعليمة أدناه في حال كنت تستخدم الألوان فقط للخلفية:

world.fill(BLUE)

وأخيرًا أخبر الوحدة Pygame لتحدّث كل ما يظهر على الشاشة مع ساعتها الداخلية، وذلك وفق الأوامر الآتية:

 pygame.display.flip()
 clock.tick(fps)

احفظ الملف وشغله، لتحظى بأكثر لعبة مملة رأيتها! وهذا طبيعي فلا شيء على الشاشة سوى خلفية اللعبة، لكن لا تقلق سنطوّرها تباعًا في المقالات اللاحقة، يمكنك الآن الضغط على q للخروج.

تثبيت البيئة الافتراضية لبايثون

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

استعرض قائمة الأدوات Tools واختر خيار "التزامن مع متطلبات بايثون" Sync Python Requirements، وستُحفظ عندها كافة اعتماديات المكتبات التي استخدمتها ضمن ملف نصي خاص يدعى requirements.txt.

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

الكود النهائي للعبة

هذا ما سيبدو عليه كود اللعبة النهائي إلى الآن:

#!/usr/bin/env python3
# by Seth Kenlon

# GPLv3
# This program is free software: you can redistribute it and/or
# modify it under the terms of the GNU General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import pygame
import sys
import os

'''
Variables
'''

worldx = 960
worldy = 720
fps = 40  # frame rate
ani = 4   # animation cycles
main = True

BLUE = (25, 25, 200)
BLACK = (23, 23, 23)
WHITE = (254, 254, 254)


'''
Objects
'''

# put Python classes and functions here


'''
Setup
'''

clock = pygame.time.Clock()
pygame.init()
world = pygame.display.set_mode([worldx, worldy])
backdrop = pygame.image.load(os.path.join('images', 'stage.png'))
backdropbox = world.get_rect()


'''
Main Loop
'''

while main:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            try:
                sys.exit()
            finally:
                main = False

        if event.type == pygame.KEYDOWN:
            if event.key == ord('q'):
                pygame.quit()
            try:
                sys.exit()
            finally:
                main = False
    world.blit(backdrop, backdropbox)
    pygame.display.flip()
    clock.tick(fps)

محطتنا التالية

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

ترجمة -وبتصرف- للمقال Build a game framework with Python using the Pygame module لصاحبه Seth Kenlon.

اقرأ أيضًا

• المقال التالي: إضافة لاعب إلى لعبة مطورة باستخدام بايثون ومكتبة Pygame
• المقال السابق: بناء لعبة نرد بسيطة بلغة بايثون
• تعرف على أشهر لغات برمجة الألعاب
• برمجة لعبة حجرة ورقة مقص باستخدام لغة بايثون
• النسخة العربية الكاملة من كتاب البرمجة بلغة بايثون

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

هذا المقال جزءًا من سلسلة مقالات حول تصميم لعبة بلغة بايثون ومكتبة Pygame وإليك كامل مقالات السلسلة:

1. بناء لعبة نرد بسيطة بلغة بايثون.
2. بناء لعبة رسومية باستخدام بايثون ووحدة الألعاب PyGame.
3. إضافة لاعب إلى اللعبة المطورة باستخدام بايثون و Pygame.
4. تحريك شخصية اللعبة باستخدام PyGame.
5. إضافة شخصية العدو للعبة.
6. إضافة المنصات إلى لعبة بايثون باستخدام الوحدة Pygame.
7. محاكاة أثر الجاذبية في لعبة بايثون.
8. إضافة خاصية القفز والركض إلى لعبة بايثون.
9. إضافة الجوائز إلى اللعبة المطورة بلغة بايثون.
10. تسجيل نتائج اللعبة المطورة بلغة بايثون وعرضها على الشاشة.
11. إضافة آليات القذف إلى اللعبة المطورة بلغة بايثون.

تثبيت بايثون

ستحتاج إلى تثبيت بايثون الإصدار 3 لتتابع معنا خطوات العمل، لذا اتبع الخطوات المناسبة لنظام تشغيلك.

إن كنت تستخدم نظام تشغيل لينكس، فستجد بايثون متوفرًا ضمنه على الأغلب، استعلم عن إصداره بالأمر التالي:

python --version

وانظر إلى الخرج فلو تبين لك أن الإصدار الموجود هو 2، أو أن بايثون غير مثبت على الإطلاق، حاول كتابة الأمر بالشكل التالي:

python3 --version

وإن حصلت على رسالة مفادها عدم التعرف على الأمر، فثبت بايثون 3 باستخدام مركز التطبيقات أو مدير الحزم الخاص بتوزيعة لينكس التي تعتمدها مثل apt في أوبونتو أو dnf في فيدورا.

إن كانت توزيعتك هي فيدورا، ثبت بايثون 3 بالأمر التالي:

sudo dnf install python3

اتبع الخطوات نفسها في نظام تشغيل macOS لتتأكد من وجود بايثون 3 في النظام، وإن لم يكن مثبتًا، حمله من موقع بايثون الرسمي ثم ثبته، وهنا لديك هذه الطريقة فقط إذ إن macOS لا يملك مدير حزم.

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

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

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

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

اشترك الآن

تشغيل بيئة التطوير المتكاملة IDE

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

بيئة التطوير IDLE 3 الأساسية

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

لبدء استخدام هذه البيئة في لينكس ونظام macOS يكفيك كتابة الأمر idle3 في نافذة الطرفية، أما لاستخدامها في ويندوز فابحث عن بايثون 3 في قائمة ابدأ وستجد هذه البيئة بين خياراتها، وفي حال لم تجد بايثون في قائمة ابدأ، افتح سطر الأوامر بكتابة cmd في خانة البحث، ومن ثم اكتب ضمنه السطر التالي:

  C:\Windows\py.exe

وإن لم ينفع، أعد تثبيت بايثون وتأكد من تفعيل خيار إضافة بايثون إلى متغير البيئة PATH في أثناء عملية التثبيت.

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

بيئة التطوير Pycharm النسخة المجتمعية

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

لتستخدم هذه البيئة ثبّت النسخة المجتمعية من Pycharm، إن كان نظام تشغيلك هو لينكس فيمكنك تثبيتها باستخدام flatpak من منصة FlatHub أو تحميلها من الموقع الرسمي وتثبيتها يدويًا، أما لو كنت تعتمد ويندوز أو macOS فحمل نسخة البرنامج المناسبة لك من موقعه الرسمي، ومن ثم ثبتها.

افتح البرنامج بعد التثبيت وأنشئ مشروعًا جديدًا.

أخبر بايثون بما تريد تنفيذه

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

print("Hello world.")

والآن شغله بإحدى الطريقتين:

• إن كنت تستخدم IDLE استعرض قائمة التشغيل وحدد الخيار "تشغيل الوحدة Run Module".
• أما في PyCharm انقر فوق الزر "تشغيل ملف Run file" ضمن أزرار شريط الأدوات.

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

وننوه لك أن بايثون افتراضيًا لا تستخدم إلّا الكلمات المفتاحية الأساسية مثل print و help وتلك الخاصة بالعمليات الحسابية الأساسية وما شابه، ولكن التعليمة import تتيح للمبرمج استيراد المزيد من الوظائف واستخدامها.

استخدام وحدة الرسم turtle في بايثون

اكتب الأسطر التالية في ملفك (بعد حذف الموجود فيه)، ومن ثم شغله:

import turtle

turtle.begin_fill()
turtle.forward(100)
turtle.left(90)
turtle.forward(100)
turtle.left(90)
turtle.forward(100)
turtle.left(90)
turtle.forward(100)
turtle.end_fill()

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

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

turtle.clear()

حاول تخمين معنى الدالة من اسمها الأجنبي:

turtle.color("blue")

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

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

import turtle as t
import time

t.color("blue")
t.begin_fill()

counter=0

while counter < 4:
    t.forward(100)
    t.left(90)
    counter = counter+1

t.end_fill()
time.sleep(2)

تعلم بايثون عبر بناء لعبة بسيطة

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

التخطيط للعبة

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

1. ابدأ اللعبة واضغط على زر Return أو Enter في لوحة المفاتيح لتبدأ دورة النرد.
2. ستظهر النتيجة على الشاشة.
3. ستُطالب بعدها بإعادة اللعب أو بالخروج.

اللعبة بسيطة هذا صحيح، لكن توثيقها سيبين لك كمًّا لا بأس به من التفاصيل لتعمل عليها، مثل حاجتك لهذه المكونات.

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

بناء الإصدار الأول من لعبة النرد

يتضمن الإصدار الأول من البرنامج الميزات الأساسية فقط، قلة هم من يبدأون تطوير برامجهم بميزات كاملة من أول إصدار.

سنعرض مفهومين أساسيين قبل البدء.

أولًا المتغير variable هو قيمة قابلة للتغيير، يستخدم لتخزين بعض المعلومات التي يحتاجها البرنامج وهو شائع الاستخدام في بايثون، فمثلًا المحرف x هو متغير في المعادلة التالية لأنه يشير إلى قيمةٍ ما أو ينوب عنها:

x + 5 = 20

وثانيًا العدد الصحيح integer فيشمل الأعداد الصحيحة الموجبة والسالبة، مثلًا: 1، ‎-1 ،14 ،10947.

يتضمن إصدارنا الأول من اللعبة -والمسمى ألفا dice-alpha- متغيرين هما player و ai.

لتبدأ بإنشائه، افتح مشروعًا جديدًا، وسمّه dice-alpha ثم اكتب ضمنه الكود التالي:

import random

player = random.randint(1,6)
ai = random.randint(1,6)

if player > ai :
    print("You win")  # لاحظ المسافة البادئة
else:
    print("You lose")

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

تحسين اللعبة

سنبني الآن الإصدار الثاني وهو الإصدار بيتا، بإضافة بعض الميزات ليصبح برنامجنا أقرب للعبة فعلًا.

1. إظهار تفاصيل النتيجة

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

جرب إجراء التعديل التالي في برنامجك، ومن ثم شغله:

player = random.randint(1,6)
print("You rolled " + player)

ai = random.randint(1,6)
print("The computer rolled " + ai)

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

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

نفذ إذًا التعديل التالي وأعد تشغيل اللعبة ولاحظ النتائج:

player = random.randint(1,6)
print("You rolled " + str(player) )

ai = random.randint(1,6)
print("The computer rolled " + str(ai) )

2. إضافة عامل التشويق

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

نفذ التالي وتفقد النتائج:

import random
import time

player = random.randint(1,6)
print("You rolled " + str(player) )

ai = random.randint(1,6)
print("The computer rolls...." )
time.sleep(2)
print("The computer has rolled a " + str(player) )

if player > ai :
    print("You win")   # لاحظ المسافة البادئة
else:
    print("You lose")

3. اكتشاف ثغرة التعادل

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

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

الآن عدّل برنامجك ليغدو كما يلي:

if player > ai :
    print("You win")  # لاحظ المسافة البادئة
elif player == ai:
    print("Tie game.")
else:
    print("You lose")

وبعدها جرب اللعبة عدة مرات لتصادف حالة التعادل وتتأكد من عملها.

يمكنك تعلم المزيد عن الدوال الشرطية في بايثون بالاطلاع على المقال كيفية كتابة التعليمات الشرطية في بايثون 3 ضمن دليل تعلم بايثون على أكاديمية حسوب.

بناء الإصدار النهائي للعبة

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

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

عدّل الآن برنامجك ليصبح:

import random
import time

def dice():
    player = random.randint(1,6)
    print("You rolled " + str(player) )

    ai = random.randint(1,6)
    print("The computer rolls...." )
    time.sleep(2)
    print("The computer has rolled a " + str(ai) )

    if player > ai :
        print("You win") 
    elif player == ai:
        print("Tie game.")
    else:
        print("You lose")

    print("Quit? Y/N")
    cont = input()

    if cont == "Y" or cont == "y":
        exit()
    elif cont == "N" or cont == "n":
        pass
    else:
        print("I did not understand that. Playing again.")

في هذا الإصدار سيُسأل اللاعب إن كان يريد الخروج من اللعبة، وفي حال أجاب بنعم عبر كتابة Y أو y، فإن بايثون سينهي استدعاء الدالة وتتم مغادرة اللعبة.

إذًا فقد بنيت دالتك الأولى المسماة نرد dice لكنها لن تعمل ما لم تستدعيها ضمن البرنامج، وهذا ما ستفعله الحلقة While True.

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

…
# الحلقة الأساسية
while True:
    print("Press return to roll your die.")
    roll = input()
    dice()

هذه الحلقة هي أول ما سيعمل في برنامجك، وتتكرر دومًا ما لم يكسرها أمرٌ من بايثون، إذ إن شرط عملها محقق دائمًا وتلقائيًا فهو True، لاحظ تسلسل عملها فهي تطالب المستخدم أولًا باتخاذ إجراء حتى يبدأ اللعب، ومن ثم تستدعي الدالة dice، ومن بعدها بناءً على إجابة المستخدم ستستمر الحلقة بالعمل أو تتوقف.

ومن الجدير بالذكر أن الحلقات هي واحدة من أشيع الطرق المستخدمة لبدء التطبيقات فهي تضمن بقاء التطبيق متاحًا أمام المستخدم لفترة كافية تمكنه من استخدام وظائفه المختلفة.

يمكنك تعلم المزيد عن الحلقات التكرارية بالاطلاع على المقال كيفية إنشاء حلقات تكرار while في بايثون 3، والمقال كيفية استخدام تعابير break و continue و pass عند التعامل مع حلقات التكرار في بايثون 3 ضمن دليل تعلم بايثون على أكاديمية حسوب.

ختامًا

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

ترجمة -وبتصرف- للمقال Learn how to program in Python by building a simple dice game لصاحبه Seth Kenlon.

اقرأ أيضًا

• المقال التالي: بناء لعبة رسومية باستخدام بايثون ووحدة الألعاب Pygame
• تعرف على أشهر لغات برمجة الألعاب
• برمجة لعبة حجرة ورقة مقص باستخدام لغة بايثون
• النسخة العربية الكاملة من كتاب البرمجة بلغة بايثون

تُعَدّ السلسلة الزمنية time series تسلسلًا sequence من القياسات المأخوذة من نظام والمتغيرة بمرور الزمن، ومن الأمثلة الشهيرة "مخطط عصا الهوكي" الذي يُظهر متوسط درجة الحرارة في العالم مع مرور الوقت، كما يمكنك الاطلاع على صفحة ويكيبيديا للمزيد من المعلومات، حيث أنّ مصدر المثال الذي نناقشه في هذا المقال هو البيانات المتاحة من موقع kaggle والتي تُعطي بيانات مبيعات الأفوكادو للأعوام 2015-2020 في الولايات المتحدة الأمريكية وذلك لكل من نوعي الأفوكادو العادي Conventional والأفوكادو العضوي Organic.

نأمل أن تجدوا هذا المقال مثيرًا للاهتمام. توجد الشيفرة الخاصة بهذا المقال في الرابط على Google Colab أو يمكنك تنزيلها من المرفقات.

استيراد وتنظيف البيانات

توجد البيانات المستخدمة في موقع Kaggle كما أرفقناها في نهاية المقال، وتُعَدّ الشيفرة التالية مسؤولةً عن قراءتها على هيئة إطار بيانات بانداز pandas DataFrame:

transactions = pandas.read_csv('avocado.csv', parse_dates=[0])

حيث أنّ مهمة الوسيط parse_dates هي الإشارة إلى الدالة read_csv لتفسير القيم الموجودة في العمود رقم 0 (العمود الأول) على أساس تواريخ ومن ثم تحويلها إلى كائنات datetime64 من نوع نمباي NumPy، كما يحتوي إطار البيانات DataFrame على سطر لكل عملية مبيع مسجلة بالإضافة إلى الأعمدة التالية:

• average_price: السعر الوسطي مقدرًا بالدولار.
• total_volume: الحجم الكلي المُباع.
• type: نوع الأفوكادو: عادي أم عضوي.
• date: تاريخ عملية المبيع.
• year: عام المبيع.
• geography: الولاية والمدينة.

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

def GroupByTypeAndDay(transactions):
    groups = transactions.groupby('type')
    dailies = {}
    for name, group in groups:
        dailies[name] = GroupByDay(group)       

    return dailies

علمًا أن groupby هو تابع خاص بأُطر البيانات وهو يُعيد كائن GroupBy باسم groups، حيث يُستخدم الكائن groups في حلقة for ليمر مرورًا تكراريًا على أسماء المجموعات وأُطر البيانات التي تمثِّلها، وبما أنّ للنوع احتمالين هما عادي أو عضوي، فسينتج مجموعتين تحمل هذه الأسماء -أي عادي وعضوي-، حيث تمر الحلقة مرورًا تكراريًا على المجموعات وتستدعي التابع GroupByDay الذي يحسب متوسط السعر اليومي ويُعيد إطار بيانات جديد:

def GroupByDay(transactions, func=np.mean):
    grouped = transactions[['date', 'average_price']].groupby('date')
    daily = grouped.aggregate(func)

    daily['date'] = daily.index
    start = daily.date[0]
    one_year = np.timedelta64(1, 'Y')
    daily['years'] = (daily.date - start) / one_year

    return daily

يُعَدّ المعامِل transactions إطار بيانات ويحتوي على العمودين date وaverage_price، لذا سنحدِّد هذين العمودين ومن ثم نجمِّعهما على أساس التاريخ، وتكون النتيجة هي grouped التي تُعَدّ خريطةً map تحوِّل كل تاريخ إلى إطار بيانات يحتوي على الأسعار التي أُبلِغ عنها في ذلك التاريخ المحدَّد، ويُعَدّ aggregate تابع تجميع GroupB يمر مرورًا تكراريًا على المجموعات ويطبق دالةً على كل عمود من المجموعة، وفي حالتنا هذه لا يوجد سوى عمود واحد هو average_price الذي يمثِّل السعر الوسطي.

تُخزَّن البيانات في هذه الأُطر على أساس كائنات نمباي NumPy من نوع datetime64 والتي تمثَّل على أساس أعداد صحيحة حجمها 46 بتًا -أي 64-bit integers- بالنانو ثانية، لكن سيكون من المناسب التعامل في بعض التحليلات القادمة مع وحدات قياس زمنية مألوفة أكثر بالنسبة للبشر مثل السنوات، أي يُضيف التابع GroupByDay عمودًا اسمه date عن طريق نسخ الفهرس ومن ثم يُضيف العمود years الذي يحتوي على عدد السنوات التي مرت منذ أول عملية مبيع وهو عدد عشري، كما يحتوي إطار البيانات الناتج على average_price الذي يمثِّل السعر الوسطي بالدولار والعمود date الذي يمثِّل التاريخ وyears.

رسم المخططات

تكون نتيجة GroupByTypeAndDay خريطةً map تحوِّل كل نوع إلى إطار بيانات يحتوي على الأسعار اليومية، وإليك الشيفرة التي استخدمناها لرسم السلسلتين الزمنيتين:

    thinkplot.PrePlot(rows=2)
    for i, (name, daily) in enumerate(dailies.items()):
        thinkplot.SubPlot(i+1)
        title = 'Average Price' if i == 0 else ''
        thinkplot.Config(ylim=[0, 3], title=title)
        thinkplot.Scatter(daily.average_price, s=10, label=name)
        if i == 1:
            pyplot.xticks(rotation=30)
        else:
            thinkplot.Config(xticks=[])

تشير الدالة PrePlot في حال وجود الوسيط rows=2 إلى أننا سنرسم مخططين فرعيين في السطرين، حيث تمر الحلقة مرورًا تكراريًا على أطر البيانات وتنشئ مخطط انتشار لكل إطار، ومن الشائع رسم السلاسل الزمنية مع قطع مستقيمة تصل بين النقطة والأخرى، لكن توجد في هذه الحالة العديد من نقاط البيانات والأسعار متغيرةً تغيرًا كبيرًا، لذا لن يكون من المفيد إضافة القطع المستقيمة، وبما أن التواريخ موجودة على محور x -أي المحور الأفقي-، فسنستخدِم pyplot.xticks للتدوير بمقدار 30 درجة، وبذلك نجعلها مقروءةً أكثر.

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

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

الانحدار الخطي

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

def RunLinearModel(daily):
    model = smf.ols('average_price ~ years', data=daily)
    results = model.fit()
    return model, results

يمكننا المرور مرورًا تكراريًا على النوعين المختلفين (العادي والعضوي) وملاءمة نموذج لكل منها:

dailies = GroupByTypeAndDay(transactions)
for name, daily in dailies.items():
    model, results = RunLinearModel(daily)
    print(results.summary()

إليك النتائج:

تشير قيم الميل المُقدَّرة إلى انخفاض سعر الأفوكادو العضوي قليلًا (2 سنتًا) في كل سنة ضمن الفترة الزمنية التي رُصدَت الأسعار فيها؛ أما الأفوكادو العادي فقد ارتفع سعره قليلًا (أقل من 1 سنتًا في كل سنة)، علمًا أن التقديرات هذه ذات دلالة إحصائية وقيمها الاحتمالية صغيرة جدًا.

إنّ قيمة R² هي 0.044 للأفوكادو العضوي أي أن الزمن بصفته متغير توضيحي يمثِّل 4%‎ من التباين المرصود في السعر، لكن يكون التغير في السعر أصغر والتباين في الأسعار أقل بالنسبة للأفوكادو العادي، لذا فإن قيم R² أصغر لكنها ما زالت ذات دلالة إحصائية، وترسم الشيفرة التالية الأسعار المرصودة والقيم الملاءمة:

def PlotFittedValues(model, results, label=''):
    years = model.exog[:,1]
    values = model.endog
    thinkplot.Scatter(years, values, s=15, label=label)
    thinkplot.Plot(years, results.fittedvalues, label='model' )

يحتوي model على exog وendog كما رأينا في قسم سابق في مقال الانحدار الإحصائي regression، حيث أنهما مصفوفتا نمباي NumPy تحتويان على المتغيرات الخارجية -أي التوضيحية- والمتغيرات الداخلية -أي التابعة-.

يوضِّح الشكل السابق سلسلةً زمنيةً للأسعار اليومية، بالإضافة إلى ملاءمة مربعات صغرى خطية linear least squares fit، كما تُنشئ الدالة PlotFiitedValues مخططًا انتشاريًا لنقاط البيانات ورسمًا خطيًا للقيم الملائمة، ويُظهر الشكل السابق نتائج الأفوكادو العضوي، حيث يبدو أنّ النموذج يلائم البيانات ملاءمةً جيدةً ولكن الانحدار الخطي ليس الخيار الأفضل لهذه البيانات:

• أولًا: ما من سبب يدفعنا للتوقُّع أنّ الاتجاه الذي استمر فترةً طويلةً هو خط أو دالة بسيطة، والذي يحدِّد الأسعار عمومًا هو العرض والطلب وكلاهما يختلف بمرور الزمن بطرق لا يمكن التنبؤ بها.
• ثانيًا: يعطي نموذج الانحدار الخطي وزنًا متساويًا لكل البيانات سواءً البيانات الحديثة أو السابقة، لكن يجب علينا إعطاء البيانات الحديثة وزنًا أكبر.
• أخيرًا: تقول إحدى الفرضيات حول الانحدار الخطي أنّ الرواسب residuals هي ضجيج غير مترابط، لكن غالبًا ما تكون هذه الفرضية غير صحيحة في حال تعاملنا مع سلاسل زمنية لأن القيم المتتالية مترابطة.

يقدِّم القسم التالي بديلًا أفضل للتعامل مع بيانات السلاسل الزمنية.

المتوسطات المتحركة

تعتمد معظم السلاسل الزمنية على افتراض النمذجة عادةً والذي يقول أنّ السلسلة المرصودة هي ناتج جمع المكوِّنات الثلاثة التالية:

• الاتجاه: هو دالة ملساء -أي منتظمة- تخزِّن التغييرات المستمرة.
• الموسمية: هو تباين دوري، وقد يتضمن دورات يومية أو أسبوعية أو شهرية أو سنوية.
• الضجيج: التباين العشوائي حول الاتجاه طويل الأمد.

يُعَدّ الانحدار أحد طرق استخراج الاتجاه من سلسلة معينة تمامًا كما رأينا في القسم السابق، لكن يوجد بديل آخر في حال لم يكن الاتجاه دالةً بسيطةً وهو المتوسط المتحرك moving average، حيث يقسِّم المتوسط المتحرك السلسلة إلى مناطق متداخلة تُدعى نوافذ windows ومن ثم يحسب متوسط القيم في كل نافذة window.

يُعَدّ المتوسط المتدحرج rolling mean الذي يحسب متوسط القيم في كل نافذة من أبسط أنواع المتوسطات المتحركة، فإذا كان حجم النافذة 3 مثلًا، فسيحسب المتوسط المتدحرج متوسط القيم من 0 إلى 2 ومن 1 إلى 3 ومن 2 إلى 4 وهكذا دواليك، كما يُبين المثال التالي:

df=pandas.DataFrame(np.arange(10))
roll_mean = df.rolling(3).mean()
print(roll_mean)

nan,  nan,   1,   2,   3,   4,   5,   6,   7,   8

نلاحظ أنّ أول قيمتين هما nan -أي ليس عددًا-؛ أما القيمة التالية فهي متوسط العناصر الثلاث الأولى أي 0 و1 و2، والقيمة التالية هي متوسط 1 و2 و3، وهكذا، حيث يتعين علينا التعامل مع القيم المفقودة في البداية وقبل تطبيق rolling على بيانات الأفوكادو، ونلاحظ في الواقع في الفترة المرصودة وجود عدة أيام لم يُبلَّغ فيها عن أيّ عمليات مبيع لنوع معين أو أكثر من نوع -أي النوع العادي أو العضوي- من الأفوكادو.

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

dates = pandas.date_range(daily.index.min(), daily.index.max())
reindexed = daily.reindex(dates)

يحسب السطر الأول من الشيفرة السابقة مجال التواريخ الذي يتضمن تاريخ كل الأيام من بداية فترة رصد عمليات المبيع حتى اليوم الأخير؛ أما السطر الثاني فينشئ إطار بيانات جديد يحتوي على كل البيانات الموجودة في daily بالإضافة إلى الأسطر التي تحتوي على جميع التواريخ ذات القيمة nan، حيث يمكننا الآن رسم المتوسط المتجدد كما يلي:

roll_mean = reindexed.average_price.rolling(30).mean()
thinkplot.Plot(roll_mean.index, roll_mean,label="rolling mean")
thinkplot.config(xlabel='date', ylabel='average-price')
thinkplot.show()

حجم النافذة هنا هو 30، لذا فإن كل قيمة في roll_mean هي متوسط 30 قيمة من reindexed.average-price.

يوضِّح الشكل السابق الأسعار اليومية والمتوسط المتدحرج rolling mean في الجهة اليسرى والمتوسط المتحرك الموزون أسيًا exponentially-weighted moving average في الجهة اليمنى، كما يُظهر الشكل السابق الموجود في الجهة اليسرى النتيجة، حيث يبدو أن المتوسط المتدحرج قد أتقن تنظيم smoothing الضجيج واستخرج الاتجاه.

البديل هو **المتوسط المتحرك الموزون أسيًا exponentially-weighted moving average -أو EWMA اختصارًا-، والذي يتمتع بميزتين اثنتين، حيث يمكننا استنتاج الميزة الأولى من الاسم، أي يحسب متوسطًا موزونًا يكون فيه لأحدث قيمة أعلى وزن؛ أما القيم السابقة فتنخفض قيمتها انخفاضًا أسيًا، والميزة الثانية هي أنّ تنفيذ بانداز pandas للمتوسط المتحرك الموزون أسيًا يعالِج القيم المفقودة بإتقان أكبر.

ewm=reindexed['average_price'].ewm(span=30).mean()
thinkplot.Plot(ewm)

يتوافق المعامِل span تقريبًا مع حجم نافذة متوسط متحرك، كما أنه يتحكم في مدى سرعة انخفاض الأوزان، لذا فهو يحدِّد عدد النقاط التي تقدِّم مساهمةً كبيرةً لكل متوسط من المتوسطات، ويُظهر الشكل السابق الموجود في الجهة اليمنى المتوسط المتحرك الموزون أسيًا EWMA الخاص بالبيانات نفسها، وهو يشبه المتوسط المتدحرج rolling mean في الحالات التي يكون كلاهما معرَّفًا، إلا أنه لا يحتوي على أي قيم مفقودة، لذا فمن السهل التعامل معه، ونلاحظ أنّ القيم تحتوي على ضجيج في بداية السلسلة الزمنية لأنها مبنية على عدد أقل من نقاط البيانات.

ewm=reindexed['average_price'].ewm(span=30).mean()
thinkplot.Plot(ewm, label="ewma")
thinkplot.config(xlabel='date', ylabel='average-price')
thinkplot.show()

القيم المفقودة

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

reindexed.average_price.fillna(ewm, inplace=True)

عندما تكون قيمة reindexed.average_price هي nan، فسيستبدلها التابع fillna بالقيم الموافقة من ewm، حيث تشير الراية inplace إلى التابع fillna لكي يعدل السلسلة الحالية بدلًا من إنشاء سلسلة جديدة، وإحدى مساوئ هذه الطريقة هي أنها تقلل من قيمة الضجيج في السلسلة، لكن يمكننا حل هذه المشكلة عن طريق إضافة الرواسب التي طُبِّق عليها أخذ عينات:

resid = (reindexed.average_price - ewm).dropna()
fake_data = ewm + thinkstats2.Resample(resid, len(reindexed))
reindexed.average_price.fillna(fake_data, inplace=True)

يحتوي المتغير resid على قيم الرواسب، لكن لا يحتوي على الأيام التي يكون فيها average_price أي السعر الوسطي هو nan، كما يحتوي fake_data على مجموع المتوسط المتحرك وعينة عشوائية من الرواسب، وأخيرًا، يستبدل التابع fillna قيم fake_data بقيم من nan.

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

الارتباط التسلسلي

قد تتوقع أن تجد أنماطًا متكررةً لأن الأسعار تتغيَّر يوميًا، فإذا كان السعر مرتفعًا يوم الاثنين، فقد تتوقع أن يكون مرتفعًا للأيام القليلة التالية، وإذا كان منخفضًا، فقد تتوقع أن يبقى منخفضًا، حيث يُدعى هذا النمط الارتباط التسلسلي serial correlation لأن كل قيمة مترابطة مع القيمة التالية في السلسلة، ويمكنك إزاحة السلسلة الزمنية بمقدار قدره تأخير lag من أجل حساب الارتباط التسلسلي ومن ثم حساب الارتباط بين السلسلة المزاحة والسلسلة الأصلية:

def SerialCorr(series, lag=1):
    xs = series[lag:]
    ys = series.shift(lag)[lag:]
    corr = thinkstats2.Corr(xs, ys)
    return corr

تكون قيم التأخير الأول nan بعد أول إزاحة، لذا فقد استخدمنا شريحةً لإزالتها قبل حساب Corr، فإذا طبقنا SerialCorr على بيانات الأسعار الأولية بقيمة تأخير 1، فسنجد أنَّ الارتباط التسلسلي 0.26 للأفوكادو العضوي و 0.39 للأفوكادو العادي، كما نتوقَّع رؤية ارتباط تسلسلي قوي في حال كانت السلسلة الزمنية ذا اتجاه طويل الأمد، فإذا كانت الأسعار تنخفض على سبيل المثال، فسنتوقع رؤية قيم النصف الأول من السلسلة أعلى من المتوسط، وقيم النصف الثاني من السلسلة أقل من المتوسط، ومن المثير للاهتمام رؤية فيما إذا كان الارتباط مستمرًا إذا لم نأخذ الاتجاه بالحسبان، إذ يمكننا مثلًا حساب راسب المتوسط المتحرك الموزون أسيًا ومن ثم حساب ارتباطه التسلسلي كما يلي:

ewm=reindexed['average_price'].ewm(span=30).mean()
resid = reindexed.average_price - ewm
corr = thinkstats2.SerialCorr(resid, 1)

تكون الارتباطات التسلسلية للبيانات التي أهملنا فيها الاتجاه في حال كانت قيمة التأخير 1 أي lag=1 هي 0.89 بالنسبة للأفوكادو العضوي، والقيمة 0.86 بالنسبة للأفوكادو العادي، كما تُعَدّ قيمًا كبيرة مما يشير إلى وجود ترابط تسلسلي يومي جيد، حيث سننفِّذ التحليل مرةً أخرى مع قيم تأخير مختلفة وذلك للتحقق من وجود موسمية أسبوعية أو شهرية أو سنوية، وإليك نتائج التحليل:

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

الارتباط الذاتي

ستضطر إلى اختبار جميع القيم إذا اعتقدت بوجود ارتباط تسلسلي في سلسلة زمنية ما لكنك لست متأكدًا من قيم التأخير التي يجب عليك اختبارها، حيث تُعَدّ دالة الارتباط الذاتي autocorrelation function دالةً تحوِّل التأخير lag إلى ارتباط تسلسلي بتأخير مُعطى، كما يُعَدّ الارتباط الذاتي والارتباط التسلسلي وجهَين لعملة واحدة، أي أنهما يشيران إلى المفهوم ذاته لكن غالبًا يُستخدَم الارتباط الذاتي عندما تكون قيمة التأخير مختلفةً عن 1، كما تزودنا StatsModels التي استخدمناها في الانحدار الخطي في المقال السابق بدوال لتحليل السلاسل الزمنية مثل acf التي تحسب دالة الارتباط الذاتي كما يلي:

  import statsmodels.tsa.stattools as smtsa
  acf = smtsa.acf(filled.resid, nlags=365)

تحسب الدالة acf الارتباطات التسلسلية مع قيم تأخير بين 0 وnlags، وتكون النتيجة مصفوفةً من الارتباطات، فإذا حددنا الأسعار اليومية للأفوكادو العضوي واستخرجنا قيم الارتباطات في حال كانت قيم التأخير هي 1 و 7 و 30 و 365، فسيمكننا عندها التأكُّد من إنتاج الدالتين acf وSerialCorr النتائج نفسها تقريبًا:

>>> acf[0], acf[1], acf[7], acf[30], acf[365]
1.000, 0.859, 0.286, -0.176, 0.000

تحسب الدالة acf ارتباط السلسلة مع نفسها إذا كانت قيمة التأخير 0 أي lag=0، علمًا أن الارتباط في هذه الحالة هو 1 دائمًا.

يوضِّح الشكل السابق دالة الارتباط الذاتي للأسعار اليومية في الجهة اليسرى؛ أما في الجهة اليمنى فيوضِّح الأسعار اليومية إذا أجرينا محاكاةً لموسمية أسبوعية، حيث يُظهر الشكل السابق في الجهة اليسرى دوال الارتباط الذاتي للأفوكادو العادي والعضوي وذلك من أجل nlags=40، حيث تُظهر المنطقة الرمادية التباين الطبيعي الذي نتوقعه إذا لم يكن هناك أي ارتباط ذاتي فعلي، علمًا أن القيم التي تقع خارج هذا المجال هي ذات دلالة إحصائية وقيمتها الاحتمالية p-value هي أقل من 5‎%‎، وبما أن معدل الإيجابية الكاذبة هو ‎5%‎ ونحن في طور حساب 120 ارتباطًا (بمعدل 40 تأخير لكل سلسلة من السلسلتين الزمنيتين)، فسنتوقع رؤية 6 نقاط خارج هذه المنطقة وفي الواقع يوجد أكثر من 6 نقاط، لذا نستنتج أنه لا يمكننا تفسير أيّ ارتباط ذاتي في السلسلة على أنه حدث بمحض الصدفة فحسب.

حسبنا المناطق الرمادية عن طريق إعادة أخذ عينات الرواسب (ويمكنك الاطلاع على شيفرتنا في في الرابط وتُدعى الدالة SimulateAutocorrelation)، ولرؤية كيف تبدو دالة الارتباط الذاتي في حال وجود موسمية من نوع ما، ولَّدنا بيانات محاكاة وذلك عن طريق إضافة دورة أسبوعية، ففي حال كان الطلب على الأفوكادو أعلى في العطل الأسبوعية، فقد نتوقع أن يكون السعر أعلى، حيث حدَّدنا التواريخ التي تصادف يومي الجمعة والسبت ومن ثم أضفنا قيمةً عشوائيةً مُختارةً من توزيع منتظم بين 0$ و 2$ على السعر وذلك من أجل محاكاة هذا التأخير.

def AddWeeklySeasonality(daily):
    frisat = (daily.index.dayofweek==4) | (daily.index.dayofweek==5)
    fake = daily.copy()
    fake.average_price[frisat] += np.random.uniform(0, 2, frisat.sum())
    return fake

يُعَدّ frisat سلسلةً بوليانيةً، بحيث تكون القيمة True ليومي الجمعة والسبت، كما يُعَدّ fake إطار بيانات جديد وهو نسخة من إطار البيانات daily بعد أن أجرينا عليه تعديل إضافة قيم عشوائية إلى average_price.frisat.sum وهو العدد الكلي لأيام الجمعة والسبت التي ظهرت، أي عدد القيم التي سيتوجب علينا توليدها.

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

التنبؤ

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

def GenerateSimplePrediction(results, years):
    n = len(years)
    inter = np.ones(n)
    d = dict(Intercept=inter, years=years)
    predict_df = pandas.DataFrame(d)
    predict = results.predict(predict_df)
    return predict

يُعَدّ results كائنًا من الصنف RegressionResults، ويُعَدّ years تسلسلًا من قيم الزمن التي نريد استنباط تنبؤاتها، كما تبني الدالة إطار بيانات وتمرره إلى الدالة predict وتُعيد النتيجة، فإذا كان ما نريد هو تنبؤ وحيد وأفضل ما في الإمكان فقط، فستكون مهمتنا قد انتهت هنا، لكن من المهم حساب الخطأ في معظم الأحيان، أي نريد بكلمات أخرى معرفة دقة التنبؤ المحتملة، كما يجب علينا أخذ مصادر الخطأ الثلاثة هذه بالحسبان:

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

من مصادر الخطأ الأخرى التي يجب علينا أخذها بالحسبان هي الحوادث المستقبلية غير المتوقعة مثل تأثر أسعار المنتجات الزراعية بالطقس وتأثر جميع الأسعار بالقوانين والسياسات، ومن الصعب حساب أخطاء النمذجة والأخطاء المستقبلية غير المتوقعة، ومن السهل التعامل مع خطأ أخذ العينات والتباين العشوائي لذا سنبدأ بهذين النوعين.

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

def SimulateResults(daily, iters=101):
    model, results = RunLinearModel(daily)
    fake = daily.copy()

    result_seq = []
    for i in range(iters):
        fake.average_price = results.fittedvalues + thinkstats2.Resample(results.resid)
        _, fake_results = RunLinearModel(fake)
        result_seq.append(fake_results)

    return result_seq

يُعَدّ daily إطار بيانات يحتوي على الأسعار المرصودة، وiters هو عدد عمليات المحاكاة التي يجب تشغيلها، كما تستخدِم الدالة SimulateResults الدالة RunLinearModel من قسم الانحدار الخطي الموجود في هذا المقال، وذلك من أجل تقدير ميل القيم المرصودة ونقطة تقاطعها، كما تولِّد الدالة مجموعة بيانات مزيفة في كل تكرار من الحلقة عن طريق إعادة أخذ عينات الرواسب وإضافتها إلى القيم الملائمة، ومن ثم تشغِّل نموذجًا خطيًا على البيانات المزيفة وتخزِّن الكائن RegresssionResults، في حين تكون الخطوة القادمة هنا هي استخدام النتائج التي أجرينا عليها محاكاةً من أجل توليد تنبؤات:

def GeneratePredictions(result_seq, years, add_resid=False):
    n = len(years)
    d = dict(Intercept=np.ones(n), years=years, years2=years**2)
    predict_df = pandas.DataFrame(d)

    predict_seq = []
    for fake_results in result_seq:
        predict = fake_results.predict(predict_df)
        if add_resid:
            predict += thinkstats2.Resample(fake_results.resid, n)
        predict_seq.append(predict)

    return predict_seq

تأخذ الدالة GeneratePredictions تسلسل النتائج من الخطوة السابقة، بالإضافة إلى القيم years والتي هي تسلسل من القيم العشرية التي تحدِّد المجال الذي يجب علينا توليد تنبؤات له، كما تأخذ هذه الدالة الوسيط add_resid الذي يخبرنا فيما إذا كان يجب إضافة رواسب مُعاد أخذ عيناتها إلى التنبؤ المباشر، حيث تمر GeneratePredictions مرورًا تكراريًا على التسلسل RegressionResults وتولِّد تسلسلًا من التنبؤات.

وأخيرًا إليك الشيفرة التي ترسم مجال الثقة 90‎%‎ للتنبؤات:

def PlotPredictions(daily, years, iters=101, percent=90):
    result_seq = SimulateResults(daily, iters=iters)
    p = (100 - percent) / 2
    percents = p, 100-p

    predict_seq = GeneratePredictions(result_seq, years, True)
    low, high = thinkstats2.PercentileRows(predict_seq, percents)
    thinkplot.FillBetween(years, low, high, alpha=0.3, color='gray')

    predict_seq = GeneratePredictions(result_seq, years, False)
    low, high = thinkstats2.PercentileRows(predict_seq, percents)
    thinkplot.FillBetween(years, low, high, alpha=0.5, color='gray')

تستدعي الدالة PlotPredictions دالة GeneratePredictions مرتين، مرةً إذا كان add_resid=True ومرةً أخرى إذا كان add_resid=False، كما تستخدِم PercentileRows لتحديد المئين 95 والمئين 5 لكل سنة، وترسم أخيرًا منطقةً رماديةً بين الحدَّين.

يُظهر الشكل السابق النتيجة، حيث تمثِّل المنطقة الرمادية الداكنة 90‎%‎ من مجال الثقة لخطأ أخذ العينات، أي عدم اليقين بشأن الميل المقدَّر ونقطة التقاطع بسبب أخذ العينات،

تُظهر المنطقة فاتحة اللون مجال ثقة 90‎%‎ لخطأ التنبؤ وهو نتيجة جمع التباين العشوائي مع خطأ أخذ العينات.

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

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

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

لقراءة أكثر تفصيلا

يُعَدّ تحليل السلاسل الزمنية موضوعًا كبيرًا، ولا يتناول هذا المقال سوى جزء يسير منه، إذ يُعَدّ الانحدار الذاتي autoregression من الأدوات الهامة للتعامل مع السلاسل الزمنية، لكنا لم نذكره في هذا المقال، ويعود ذلك إلى أنه قد تبين أنه ليس مفيدًا للبيانات التي عملنا معها، لكن سيؤهلك فهمك للمواد الموجودة في هذا المقال لتعلُّم الانحدار الذاتي، كما يمكننا اقتراح مصدر يتناول موضوع تحليل السلاسل الزمنية وهو تحليل البيانات باستخدام أدوات مفتوحة المصدر، أروايلي ميديا، 2011 (Data Analysis with Open Source Tools, O’Reilly Media, 2011) للكاتب فيليب جارنيت Philipp Janert، حيث يُعَدّ المقال الذي يتحدث فيه عن تحليل السلاسل الزمنية استمرارًا لهذا المقال.

تمارين

إليك التمارين التالية لحلها والتدرب عليها، وانتبه إلى أننا تصرفنا في النص أثناء ترجمته لذا لن تكون الحلول في الملف chap12soln.py في مستودع الشيفرات ThinkStats2 على GitHub صالحة.

تمرين 1

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

استخدم نموذجًا تربيعيًا لملاءمة السلسلة الزمنية للأسعار اليومية، واستخدم هذا النموذج لتوليد التنبؤات، لكن سيكون عليك في البداية كتابة نسخة من RunLinearModel لتستطيع تشغيل هذا النموذج التربيعي، وبعد ذلك يمكنك توليد التنبؤات عن طريق إعادة استخدام الشيفرة التي استخدمناها في هذا المقال.

تمرين 2

اكتب تعريفًا للصنف SerialCorrelationTest يرث الصنف HypothesisTest من القسم HypothesisTest الموجود في مقال اختبار الفرضيات الإحصائية، بحيث يأخذ سلسلةً series وتأخيرًا lag على أساس وسيطين، ومن ثم يحسب الارتباط التسلسلي للسلسلة مع التأخير المُعطى، ثم يحسب الصنف القيمة الاحتمالية p-value للارتباط المرصود.

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

تمرين 3

يمكننا توسيع نموذج المتوسط المتحرك الموزون أسيًا EWMA لتوليد التنبؤات باستخدام عدة طرق، ومن أبسطها اتباع الخطوات التالية:

1. احسب المتوسط المتحرك الموزون أسيًا EWMA للسلسلة الزمنية، ومن ثم استخدِم النقطة الأخيرة على أساس نقطة تقاطع inter.
2. احسب المتوسط المتحرك الموزون أسيًا EWMA للفروق بين العناصر المتتالية في السلسلة الزمنية، ومن ثم استخدِم النقطة الأخيرة على أساس ميل slope.
3. احسب inter+slope * dt للتنبؤ بالقيم المستقبلية، حيث أنّ dt هو الفرق بين زمن التنبؤ وزمن آخر عملية رصد.

استخدِم هذه الطريقة لتوليد تنبؤات لمدة سنة بعد آخر عملية رصد، وإليك بعض التلميحات:

• استخدِم timeseries.FillMissing لملء القيم المفقودة قبل إجراء هذا التحليل لكي يكون الزمن بين العناصر المتتالية متسقًا.
• استخدِم Series.diff لحساب الفرق بين العناصر المتتالية.
• استخدِم reindex لتوسيع فهرس إطار البيانات في المستقبل.
• استخدِم fillna لوضع القيم التي تنبأت بها في إطار البيانات.

ترجمة وبتصرف للفصل Chapter 12 Time series Analysis من كتاب Think Stats: Exploratory Data Analysis in Python.

الملف المرفق dataset.zip.

اقرأ أيضًا

• المقال التالي: كيفية إجراء تحليل البقاء لمعرفة المدة الافتراضية للأشياء
• المقال السابق: الانحدار الإحصائي regression ودوره في ملاءمة النماذج المختلفة مع أنواع البيانات المتاحة

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

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

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

توجد الشيفرة الخاصة بهذا المقال في الملف normal.py، في مستودع الشيفرات ThinkStats2 على GitHub.

التوزيع الطبيعي

دعنا نتحدث عن المسألة الموجودة في مقال التقدير Estimation الإحصائي في بايثون:

اقتباس

لنفترض أنك عالم تهتم بدراسة الغوريلات في محمية للحياة البرية، وقد تجد عند وزن 9 إناث أنّ x̄=90 kg والانحراف المعياري للعينة هو S = 7.5 kg؛ فإذا استخدمت x̄ لتقدير متوسط جميع الأفراد، فما هو الخطأ المعياري للمقدار؟

يجب أن يكون توزيع أخذ عينات x̄ معروفًا إذا أردنا الإجابة على هذا السؤال، وكما رأينا في قسم توزيع أخذ العينات في مقال التقدير Estimation الإحصائي في بايثون المشار إليه بالأعلى، فإننا قرّبنا التوزيع عن طريق إجراء محاكاة للتجربة -أي تجربة وزن 9 إناث غوريلا- ثم حساب x̄ لكل تجربة محاكاة وتجميع توزيع التقديرات، وتكون النتيجة هنا هي تقريب لتوزيع أخذ العينات، ثم نستخدِم توزيع أخذ العينات لحساب الأخطاء المعيارية وفواصل الثقة:

1. يُعَدّ الانحراف المعياري لتوزيع أخذ العينات هو الخطأ المعياري للتقدير، ويكون في هذا المثال حوالي 2.5 كيلوغرامًا.
2. الفاصل بين المئين 5 والمئين 95 لتوزيع أخذ العينات هو فاصل ثقة ‎90%‎ تقريبًا، وإذا أجرينا التجربة عدة مرات، فسنتوقع أن يكون التقدير في هذا الفاصل ‎90% من المرات، حيث تكون قيمة فاصل الثقة 90‎%‎ في هذا المثال هي (94, 86) كيلوغرامًا.

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

حيث يشير الرمز ∼ إلى أن الكمية موزعة ويشير الرمز N إلى طبيعي normal؛ أما التحويل الخطي لـ X فهو ‎X′ = a X + b، حيث أنّ a وb هما عددان حقيقيان، وتكون عائلة من التوزيعات مغلقةً في التحويل الخطي إذا كانت X′‎ في عائلة X نفسها، ويكون للتوزيع الطبيعي هذه الخاصية إذا كان X ∼ N (µ, σ²).

تُعَدّ التوزيعات الطبيعية مغلقةً في الإضافة، فإذا كانت Z = X + Y و X ∼ N (µX, σX²) وY ∼ N (µY, σY²) فيكون:

تكون المعادلة التالية محققة في الحالة الخاصة عندما Z = X + X

إذا سحبنا n قيمة من X وجمعناها يكون عمومًا:

توزيعات أخذ العينات

لدينا كل ما نحتاجه لحساب توزيع أخذ عينات x̄، وتذكَّر أنه سنحسب x̄ عن طريق وزن n إناث غوريلا ونجمع القيم لنحسب الوزن الكلي ثم نقسم المجموع على n، فبفرض أنّ X توزيع أوزان الغوريلا هو توزيع طبيعي تقريبًا:

يكون الوزن الكلي Y موزعًا إذا وزَنّا n غوريلا.

يكون Z متوسط العينة موزعًا إذا قسمنا على n وبالاستعانة بالمعادلة الثالثة.

Z ∼ N(, 2ln)

بالاستعانة بالمعادلة الأولى بافتراض a = 1/n.

يكون توزيع Z هو توزيع أخذ عينات x̄، ومتوسط Z هو µ الذي يظهر أن x̄ هو تقدير غير متحيز للمقدار µ، في حين يكون تباين توزيع أخذ العينات هو σ²/n، لذا فإن الانحراف المعياري لتوزيع أخذ العينات الذي يمثل الخطأ المعياري للتقدير هو σ / √n، ويكون σ في هذا المثال هو 7.5 كيلوغرامًا وn هو 9، لذا يكون الخطأ المعياري هو 2.5 كيلوغرامًا، ونلاحظ أنّ النتيجة متسقة مع التقدير الذي نتج عن المحاكاة لكن أسرع في الحساب.

يمكننا أيضًا استخدام توزيع أخذ العينات لحساب فواصل الثقة، حيث أنّ فاصل الثقة ‎90% لـ x̄ هو الفاصل بين المئين 9 والمئين 95 لـ Z، وبما أنّ توزيع Z توزيع طبيعي، فيمكننا حساب قيم المئين عن طريق تقييم دالة التوزيع التراكمي العكسية، كما لا يوجد شكل مغلق من دالة التوزيع التراكمي للتوزيع الطبيعي أو دالة التوزيع التراكمي العكسية، لكن توجد أساليب عددية سريعة وهي موجود على أساس تنفيذ برمجي في حزمة ساي باي SciPy كما رأينا في قسم التوزيع الطبيعي في مقال نمذجة التوزيعات Modelling distributions في بايثون، كما تزودنا مكتبة thinkstats2 بدالة مغلفة تجعل دالة ساي باي SciPy سهلة الاستخدام:

def EvalNormalCdfInverse(p, mu=0, sigma=1):
    return scipy.stats.norm.ppf(p, loc=mu, scale=sigma)

يعيد المئين الموافق من توزيع طبيعي له الوسيطين mu وsigma إذا كان لدينا احتمال p، كما حسبنا من أجل فاصل الثقة ‎90% للمقدار x̄ المئين 5 والمئين 95 كما يلي:

>>> thinkstats2.EvalNormalCdfInverse(0.05, mu=90, sigma=2.5)
85.888

>>> thinkstats2.EvalNormalCdfInverse(0.95, mu=90, sigma=2.5)
94.112

لذا إذا أجرينا التجربة عدة مرات، فسنتوقع أن يكون التقدير في المدى (94.1, 85.9) حوالي ‎90% من المرات، وهذا متسق مع النتائج التي حصلنا عليها عندما أجرينا محاكاة.

تمثيل التوزيعات الطبيعية

عرّفنا صنفًا يدعى Normal يمثِّل التوزيع الطبيعي ويرمز المعادلات الموجودة في الأقسام السابقة بهدف توضيح هذه الحسابات، أي كما يلي:

class Normal(object):

    def __init__(self, mu, sigma2):
        self.mu = mu
        self.sigma2 = sigma2

    def __str__(self):
        return 'N(%g, %g)' % (self.mu, self.sigma2)

يمكننا استنساخ الصنف Normal لتمثيل توزيع أوزان الغوريلا:

>>> dist = Normal(90, 7.5**2)
>>> dist
N(90, 56.25)

يزودنا الصنف Normal بالدالة Sum التي تأخذ حجم العينة n وتعيد توزيع مجموع n قيمة باستخدام المعادلة الثالثة:

    def Sum(self, n):
        return Normal(n * self.mu, n * self.sigma2)

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

    def __mul__(self, factor):
        return Normal(factor * self.mu, factor**2 * self.sigma2)

    def __div__(self, divisor):
        return 1 / divisor * self

يمكننا الآن حساب توزيع أخذ عينات المتوسط مع حجم عينة قدره 9:

>>> dist_xbar = dist.Sum(9) / 9
>>> dist_xbar.sigma
2.5

يكون الانحراف المعياري لتوزيع أخذ العينات هو 2.5 كيلوغرامًا كما رأينا في القسم السابق، وأخيرًا يزودنا الصنف Normal بالدالة Percentile التي تحسب فاصل الثقة كما يلي:

>>> dist_xbar.Percentile(5), dist_xbar.Percentile(95)
85.888 94.113

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

مبرهنة النهاية المركزية

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

وبتحديد أكبر، إذا كان لتوزيع القيم متوسطًا µ وانحرافًا معياريًا σ، فسيكون توزيع المجموع N(n µ, nσ ²) تقريبًا، وتكون هذه النتيجة هي مبرهنة النهاية المركزية -أو CLT اختصارًا-، إذ تُعَدّ من أفضل الأدوات للتحليل الإحصائي، لكن مع بعض التحذيرات وهي:

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

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

اختبار مبرهنة النهاية المركزية

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

def MakeExpoSamples(beta=2.0, iters=1000):
    samples = []
    for n in [1, 10, 100]:
        sample = [np.sum(np.random.exponential(beta, n))
                  for _ in range(iters)]
        samples.append((n, sample))
    return samples

تولِّد الدالة MakeExpoExamples عينات من مجاميع القيم الأسية، حيث استخدمنا مصطلح القيم الأسية على أساس اختصار لجملة القيم المأخوذة من توزيع أسي، ويكون beta هو وسيط التوزيع؛ أما iters هو عدد المجاميع التي يجب توليدها، ولتفسير هذه الدالة سنبدأ من الداخل أولًا، حيث نحصل على تسلسل من n قيمة أسية في كل استدعاء للدالة np.normal.exponential ونحسب مجموعها.

يُعَدّ sample قائمةً لهذه المجاميع وبطول iters، ومن الصعب التمييز بين n وiters، لكن n هو عدد التعبيرات في كل مجموع، وiters هو عدد المجاميع التي نحسبها لوصف توزيع المجاميع، حيث أنّ القيمة المعادة هي قائمة من أزواج (n, sample)، ثم ننشئ رسمًا احتماليًا طبيعيًا لكل زوج:

def NormalPlotSamples(samples, plot=1, ylabel=''):
    for n, sample in samples:
        thinkplot.SubPlot(plot)
        thinkstats2.NormalProbabilityPlot(sample)

        thinkplot.Config(title='n=%d' % n, ylabel=ylabel)
        plot += 1

تأخذ NormalPlotSamples قائمة الأزواج من MakeExpoSamples وتولِّد سطرًا من رسوم الاحتمالات الطبيعية.

يوضِّح الشكل السابق توزيع مجاميع القيم الأسية في السطر العلوي والقيم اللوغاريتمية الطبيعية في السطر السفلي، كما يُظهر الشكل السابق الموجود في الأعلى النتائج، إذ يكون توزيع المجموع أسيًا من أجل n=1، لذا فإن رسم الاحتمال الطبيعي ليس مستقيمًا، لكن إذا كان n=10، فيكون توزيع المجموع طبيعيًا تقريبًا، وإذا كان n=100، فلا يمكن تمييز التوزيع عندها عن الطبيعي.

يُظهر الشكل السابق في السطر السفلي نتائجًا مشابهةً للتوزيع اللوغاريتمي الطبيعي، إذ عادةً ما تكون التوزيعات اللوغاريتمية الطبيعية أكثر تجانفًا من التوزيعات الأسية، لذا يأخذ توزيع المجاميع وقتًا أطول لكي يتقارب، وإذا كان n=10، يكون الرسم الاحتمالي الطبيعي أبعد ما يكون عن المستقيم، لكن إذا كان n=100 فيكون التوزيع طبيعيًا تقربيًا.

يُظهر الشكل السابق توزيعات مجاميع قيم باريتو Pareto في السطر العلوي والقيم الأسية المترابطة في السطر السفلي، حيث تُعَدّ توزيعات باريتو Pareto أكثر تجانفًا من التوزيعات اللوغاريتمية الطبيعية، وغالبًا لا يكون للعديد من توزيعات باريتو Pareto متوسطًا وتباينًا محدودَين اعتمادًا على المعامِلات، وبالتالي لا تنطبق مبرهنة النهاية المركزية على توزيع باريتو Pareto، كما يُظهر الشكل السابق في السطر العلوي توزيعات مجاميع قيم باريتو Pareto، فحتى إذا كان n=100، فسيكون الرسم الاحتمالي الطبيعي أبعد ما يكون عن المستقيم.

ذكرنا أيضًا أنه لا يمكن تطبيق مبرهنة النهاية المركزية إذا كانت القيم مترابطةً، ولاختبار ذلك سنولِّد قيمًا مترابطةً من التوزيع الأسي، علمًا أنّ خطوات الخوارزمية لتوليد القيم المترابطة هي:

1. توليد القيم العادية المترابطة.
2. استخدام دالة التوزيع التراكمي الطبيعي لجعل القيم موحدةً. 3.استخدام دالة التوزيع التراكمي العكسية الأسية لتحويل القيم الموحَّدة إلى أسية.

تعيد الدالة GenerateCorrelated مكررًا لـ n قيمة طبيعية من الارتباط التسلسلي rho :

def GenerateCorrelated(rho, n):
    x = random.gauss(0, 1)
    yield x

    sigma = math.sqrt(1 - rho**2)
    for _ in range(n-1):
        x = random.gauss(x*rho, sigma)
        yield x

تكون القيمة الأولى قيمةً طبيعيةً معياريةً، وتعتمد كل قيمة لاحقة على سابقتها، أي إذا كانت القيمة السابقة هي x، فيكون متوسط القيمة التالية هوx * rho ويكون التباين هو 1‎-rho**2، علمًا أنّ random.gauss تأخذ الانحراف المعياري على أساس وسيط ثان وليس التباين، كما تأخذ الدالة GenerateExpoCorrelated التسلسل الناتج وتجعله أسيًا:

def GenerateExpoCorrelated(rho, n):
    normal = list(GenerateCorrelated(rho, n))
    uniform = scipy.stats.norm.cdf(normal)
    expo = scipy.stats.expon.ppf(uniform)
    return expo

حيث يكون normal قائمةً من القيم الطبيعية المترابطة، وuniform تسلسلًا من القيم الموحَّدة التي تقع بين 0 و1، وexpo تسلسلًا مترابطًا من القيم الأسية، في حين ترمز ppf إلى دالة نقطة النسبة المئوية percent point function التي هي اسم آخر لدالة التوزيع التراكمي المعكوسة.

يُظهر الشكل السابق في السطر السفلي توزيعات مجاميع القيم الأسية المترابطة إذا كان rho=0.9، ويبطئ الترابط من معدل التقارب، لكن إذا كان n=100، فيكون الرسم الاحتمالي الطبيعي مستقيمًا تقريبًا، لذا على الرغم من أنّ مبرهنة النهاية المركزية لا تطبق تمامًا عندما تكون القيم مترابطة، إلا أنه نادرًا ما تشكِّل الترابطات المتوسطة مشكلةً أثناء التطبيق العملي، كما تهدف هذه التجارب إلى إظهار الطريقة التي تعمل بها مبرهنة النهاية المركزية بالإضافة إلى إظهار ماذا يحدث عندما لا تعمل، ودعونا الآن نرى كيف يمكننا استخدامها.

تطبيق مبرهنة النهاية المركزية

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

>>> live, firsts, others = first.MakeFrames()
>>> delta = firsts.prglngth.mean() - others.prglngth.mean()
0.078

تذكَّر منطق اختبار الفرضيات: نحسب القيمة الاحتمالية p-value وهي احتمال الفرق المرصود في ظل فرضية العدم، فإذا كان الاحتمال صغيرًا، فنستنتج أنه من غير المرجح أن يكون الفرق المرصود ناجمًا عن الصدفة فحسب، وتكون فرضية العدم في هذا المثال هي أنّ توزيع مدة الحمل هي نفسها للأطفال الأوائل ولبقية الأطفال، لذا يمكننا حساب توزيع أخذ عينات المتوسط كما يلي:

    dist1 = SamplingDistMean(live.prglngth, len(firsts))
    dist2 = SamplingDistMean(live.prglngth, len(others))

علمًا أنّ توزيعي أخذ العينات مبنيان على البيانات نفسها وهي مجموعة الولادات الحية كلها، حيث تأخذ SamplingDistMeans تسلسلًا من القيم وحجم العينة، وتعيد كائنًا طبيعيًا يمثِّل توزيع أخذ العينات:

def SamplingDistMean(data, n):
    mean, var = data.mean(), data.var()
    dist = Normal(mean, var)
    return dist.Sum(n) / n

يمثِّل mean متوسط البيانات؛ أما var فهو التباين، وسننشئ تقريبًا لتوزيع البيانات بالاستعانة بتوزيع طبيعي dist، إذ يُعَدّ توزيع البيانات في هذا المثال لاطبيعيًا، لذا فإنّ هذا التقريب غير جيد، لكن علينا الآن حساب dis.Sum(n)/n وهو توزيع أخذ عينات متوسط n قيمة، ويكون حسب مبرهنة النهاية المركزية أنّ توزيع أخذ عينات المتوسط هو توزيع طبيعي حتى لو لم يكن توزيع البيانات طبيعيًا، ثم نحسب توزيع أخذ عينات الفرق في المتوسطات، حيث يعلم الصنف Normal كيفية تطبيق الطرح باستخدام المعادلة الثانية:

    def __sub__(self, other):
        return Normal(self.mu - other.mu,
                      self.sigma2 + other.sigma2)

لذا يمكننا حساب توزيع أخذ عينات الفرق كما يلي:

>>> dist = dist1 - dist2
N(0, 0.0032)

يكون المتوسط هو 0، وهذا منطقي لأننا نتوقع أن يكون للعينتين من التوزيع نفسه المتوسط نفسه وسطيًا، ويكون تباين توزيع أخذ العينات هو 0.0032، كما يزودنا الصنف Normal بالدالة Prob التي تقيّم دالة التوزيع التراكمي الطبيعية، ويمكننا استخدام Prob لحساب احتمالية وجود فرق بحجم delta في ظل فرضية العدم:

>>> 1 - dist.Prob(delta)
0.084

يعني هذا أنّ القيمة الاحتمالية للاختبار أحادي الجانب هو 0.84؛ أما بالنسبة للاختبار ثنائي الجانب فسنحسب كما يلي:

>>> dist.Prob(-delta)
0.084

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

اختبار الارتباط

استخدمنا في قسم اختبار الارتباط في مقال اختبار الفرضيات الإحصائية من هذه السلسلة والمشار إليه بالأعلى، اختبار التبديل permutation test لاختبار الارتباط بين وزن الطفل عند الولادة وعمر الأم، ووجدنا أنه ذو دلالة إحصائية والقيمة الاحتمالية هي أقل من 0.001، حيث يمكننا فعل الشيء ذاته لكن بأسلوب تحليلي مبني على نتيجة رياضية: إذا كان لدينا متغيرين موزعَين طبيعيًا وغير مترابطَين، فإذا ولدنا عينةً حجمها n وحسبنا ارتباط بيرسون r ثم حسبنا الارتباط بعد التحويل، يكون:

يُعَدّ توزيع t هو توزيع ستيودنت الاحتمالي Student’s t-distribution مع معامِل n-2، حيث يُعَدّ التوزيع t توزيعًا تحليليًا، ويمكن حساب دالة التوزيع التراكمي بفعالية باستخدام دوال غاما gamma، حيث يمكننا استخدام النتيجة لحساب توزيع أخذ عينات الارتباط في ظل فرضية العدم، أي إذا ولَّدنا التسلسلات غير المترابطة للقيم الطبيعية، فما هو توزيع الارتباط؟ تأخذ الدالة StudentCdf حجم العينة n ويُعيد توزيع أخذ عينات الارتباط:

def StudentCdf(n):
    ts = np.linspace(-3, 3, 101)
    ps = scipy.stats.t.cdf(ts, df=n-2)
    rs = ts / np.sqrt(n - 2 + ts**2)
    return thinkstats2.Cdf(rs, ps

حيث أنّ ts هي مصفوفة نمباي NumPy لتوزيع t وهو الارتباط بعد التحويل، كما تحتوي ps على الاحتمالات الموافقة المحسوبة باستخدام دالة التوزيع التراكمي لتوزيع ستيودنت الاحتمالي وهي منفَّذة برمجيًا في حزمة ساي باي SciPy، ويمثِّل معامِل توزيع t (أي t-distribution) الذي يدعى df درجات الحرية degrees of freedom، ولن نشرح هذا المصطلح لكن يمكنك القراءة عنه في صفحة الويكيبيديا.

يوضِّح الشكل السابق توزيع أخذ عينات ارتباط القيم الطبيعية غير المرتبطة، ويتوجب علينا تطبيق التحويل العكسي إذا أردنا تحويل ts إلى معاملات الترابط rs:

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

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

    t = r * math.sqrt((n-2) / (1-r**2))
    p_value = 1 - scipy.stats.t.cdf(t, df=n-2)

نحسب قيمة t الموافقة لـ r=0.07 ثم نقيِّم توزيع t عند t، ونلاحظ أنّ النتيجة هي 2.9e-11، إذ يُظهر هذا المثال إحدى ميزات الأسلوب التحليلي، حيث يمكننا حساب قيم احتمالية صغيرة جدًا لكن لا يهمنا هذا الأمر في الحالات الواقعية عادةً.

اختبار مربع كاي

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

يُعَدّ توزيع أخذ العينات فيها تحليليًا في ظل فرضية العدم، وهو من أسباب شيوع استخدام إحصائية مربع كاي، وبصدفة رائعة فإنه يدعى توزيع مربع كاي، ويمكن حساب دالة التوزيع التراكمي لمربع كاي بكفاءة باستخدام دوال غاما تمامًا مثل توزيع t.

يوضِّح الشكل السابق توزيع أخذ عينات إحصائية مربع كاي للنرد العادل ذي الوجوه الستة، حيث تزودنا مكتبة ساي باي SciPy بتنفيذ برمجي لتوزيع مربع كاي الذي يمكننا استخدامه لحساب توزيع أخذ عينات إحصائية مربع كاي كما يلي:

def ChiSquaredCdf(n):
    xs = np.linspace(0, 25, 101)
    ps = scipy.stats.chi2.cdf(xs, df=n-1)
    return thinkstats2.Cdf(xs, ps)

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

    p_value = 1 - scipy.stats.chi2.cdf(chi2, df=n-1)

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

نقاش

تركِّز هذه السلسلة على الأساليب الحسابية مثل إعادة أخذ العينات والتبديل، وتملك هذه الأساليب ميزات لا تمتلكها الأساليب التحليلية مثل:

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

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

1. استخدم الأساليب الحسابية أثناء الاستكشاف، وإذا وجدت إجابةً مرضيةً وزمنًا مقبولًا للتنفيذ، يمكنك التوقف.
2. إذا لم يكن زمن التنفيذ مقبولًا، فابحث عن حلول للتحسين.
3. إذا كان استخدام الأسلوب التحليلي أنسب من الأسلوب الحسابي، فاستخدم الأسلوب الحسابي ليكون أساسًا للمقارنة، إذ سيوفِّر لك هذا الأمر إمكانية التحقق المتبادل في النتائج الحسابية والتحليلية.

لم تتطلب معظم المسائل التي عملت عليها تجاوز الخطوة الأولى من العملية السابقة.

تمارين

يوجد حل هذه التمارين في الملف chap14soln.py في مستودع الشيفرات ThinkStats2 على GitHub..

تمرين 1

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

حيث أنّ w هو وزن البالغ، وw<sub>0</sub>‎ هو وزن الطفل عند الولادة، وf<sub>i</sub>‎ هو عامل الوزن المكتسب في العام i، علمًا أنّ لوغاريتم الجداء هو جمع لوغاريتمات العوامل:

يكون توزيع logw حسب مبرهنة النهاية المركزية طبيعيًا تقريبًا إذا كانت n كبيرةً، مما يعني أنّ توزيع w لوغاريتمي طبيعي، ويمكنك من أجل نمذجة هذه الظاهرة اختيار توزيع منطقي لـ f ثم توليد عينة من أوزان البالغين عن طريق اختيار قيمة عشوائية من توزيع أوزان المواليد ثم اختيار تسلسل عوامل من توزيع f وحساب الجداء؛ ما هي قيمة n التي نحتاجها للتقارب من توزيع لوغاريتمي طبيعي؟

تمرين 2

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

أوجد هذا التوزيع واستخدمه لحساب الخطأ المعياري وفاصل الثقة ‎90% للفرق في المتوسطات.

تمرين 3

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

سجّل الطلاب الذكور قبل التدخل درجات أعلى فيما يخص البرمجة في المشروع مقارنةً بالطالبات، وسجّل الرجال في المتوسط درجة 3.57 مع خطأ معياري قدره 0.28، بينما سجّلت النساء في المتوسط 1.91 مع خطأ معياري قدره 0.32.

احسب توزيع أخذ العينات للفجوة بين الجنسين -أي الفرق في المتوسطات-، واختبر ما إذا كان التوزيع ذا دلالة إحصائية، ولا تحتاج إلى معرفة حجم العينة لتحسب توزيعات أخذ العينات لأنك تعلم الأخطاء المعيارية للمتوسطات المقدَّرة.

أصبحت الفجوة بعد التدخل أصغر، حيث أصبح المتوسط الحسابي للرجال هو 3.44 وبخطأ معياري قدره 0.16؛ أما المتوسط الحسابي للنساء فهو 3.18 وبخطأ معياري قدره 0.16؛ احسب توزيع العينات للفجوة بين الجنسين مرةً أخرى واختبرها.

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

ترجمة -وبتصرف- للفصل Chapter 14 Analytics methods analysis من كتاب Think Stats: Exploratory Data Analysis in Python.

اقرأ أيضًا

• المقال السابق: كيفية إجراء تحليل البقاء لمعرفة المدة الافتراضية للأشياء
• العلاقات بين المتغيرات الإحصائية وكيفية تنفيذها في بايثون
• التوزيعات الإحصائية في بايثون

سنغطي في هذا المقال من سلسلة تعلم البرمجة ما يلي:

• آلية ووقت استخدام التزامن concurrency والخيوط threads.
• مثال على تقسيم الحمل بين العمليات.
• الوصول إلى البيانات المشتركة باستخدام الخيوط.
• بعض الاحتمالات والمحاذير الأخرى.

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

مفهوم البرمجة التزامنية وتوقيت استخدامها

تشير البرمجة التزامنية Concurrent programming ببساطة إلى برنامج يحوي عناصر تعمل على التوازي في نفس الوقت، وهو ما نطبقه على حواسيبنا كل يوم، لكننا نترك أمر إدارة تلك البرامج لنظام التشغيل، ليجدولها لتعمل بالترتيب، ويوزع حمل التشغيل على المعالجات والنوى kernels الموجودة فيها، فمفهوم تقسيم المهمة إلى عدة أجزاء والعمل على كل جزء على حدة ليس جديدًا، وهو يشبه إنشاء فرق مختلفة للتعامل مع مشكلة كبيرة تُقسم إلى عدة أجزاء، ليعمل كل فريق على جزء منها.

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

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

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

اختيار أسلوب التزامن

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

• نستخدم الخيوط إذا كان في المهمة انتظار لنشاط الإدخال والإخراج، مثل رسائل الشبكة أو نتائج استعلامات قواعد البيانات.
• نستخدم الخيوط إذا تطلبت المهمة مشاركة البيانات بين عدة "خيوط"، لكن يجب تذكر قفل lock البيانات المشارَكة أثناء التحديثات.
• نستخدم العمليات الفرعية إذا كان في المهمة معالجة خالصة للبيانات data crunching، وقد صممت الوحدة multiprocessing في بايثون خصيصًا لهذه الحالة.
• إذا كانت المهمة الفرعية تعمل لوقت طويل، أو لا تُستدعى إلا لوقت قصير، فننشئ عملية خادم طويلة التشغيل long running server process، كما فعلنا في مقال التواصل بين العمليات، لنرسل البيانات إليها عند الحاجة.

اقتباس

تواجه بايثون مشكلةً كبيرةً في منظورها للخيوط تنطوي على آليةً داخليةً معقدةً، تسمى قفل المفسر العام Global Interpreter Lock أو GIL اختصارًا، يتمثل تأثير هذا القفل في منع خيوط العمليات الحسابية من العمل بالكفاءة التي نريدها، إلى الحد الذي دفع البعض إلى القول بعدم استخدام الخيوط في بايثون بالكلية، غير أن في مبالغةً كبيرةً، إذ إن الخيوط طريقة ممتازة للتعامل مع كل ما يجب قفله لعمليات الإدخال والإخراج، وهذا يعني "كل شيء" تقريبًا، والمهام الحسابية الخالصة فقط هي التي تواجه مشاكل، وليست المشاكل فيها بذلك السوء كما سنرى في المثال أدناه، وسنستخدم وحدة multiprocessing عندما نواجه تلك المشاكل، وهي مماثلة للخيوط في استخدامها، وستنفذ نفس المهمة لكن مع استخدام العمليات بدلًا من الخيوط، وهو الخيار الذي يستهلك الموارد كما ذكرنا في بداية المقال.

البدء بالبرمجة المتزامنة

بما أننا قررنا استخدام التزامن فلننظر في الشيفرة المطلوبة لها، لدينا وحدتان في المكتبة القياسية تتعلقان بالخيوط، هما Thread وthreading، والوحدة الأخيرة هي وحدة عالية المستوى بُنيت فوق وحدة Thread، ولا نحتاج إلا إلى النظر فيها، أما في حالة العمليات المتعددة فنستخدم وحدة multiprocessing التي تعمل تقريبًا بنفس طريقة threading.

تحديد المشكلة

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

import time, sys

factorials = []

def fact(n):
    if n < 2: return 1

    result = 1.0
    for x in range(2,n+1):
        result *= x
    return result

def do_it(f,lo,hi):
    global factorials
    for n in range(lo,hi):
        factorials.append(f(n))

if __name__ == "__main__":
    hi = int(sys.argv[1]) + 1
    start = time.time()
    
    do_it(fact, 1, hi)    
    print('Time for %s: %s' % (hi, time.time() - start))

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

احفظ ذلك في ملف باسم no_threads.py وشغله لأول 100 عدد كما يلي:

$ python3 no_threads.py 100

إذا شغلنا هذا الأمر فسنجد أن الوقت المستغرق أقل من ثانية، نظرًا لسرعة الحواسيب هذه الأيام، لكن جرب ذلك مع أول ألف عدد مثلًا وانظر الوقت المستغرق، وقد جربناها لكل من أول 100 عدد، وأول 1000، وأول 10000، وخرجنا بالنتائج التالية:

$ python3 no_threads.py 100
Time for 100: 0.0006973743438720703
$ python3 no_threads.py 1000
Time for 1000: 0.06539225578308105
$ python3 no_threads.py 10000
Time for 10000: 6.800917863845825

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

إضافة التزامن إلى العملية

باتباع الإرشادات التي شرحناها أعلاه، سنختار multiprocessing بدلًا من threading لهذه المهمة، ونريد أن نعرف مقدار العدد المُدخَل أولًا، فإذا كان أكثر من 1000، فسنقسم العملية إلى عدة فروع، وسيكون ذلك أبطأ في الأعداد الكبيرة، لذلك بدلًا من تقسيم البيانات بالتساوي بين العمليات سنقسمها عند 75% -عشوائيًا-.

ستكون الشيفرة كما يلي:

import time, sys
import multiprocessing

factorials = []

def fact(n):
    if n < 2: return 1

    result = 1.0
    for x in range(2,n+1):
        result *= x
    return result

def do_it(f,lo,hi):
    global factorials
    for n in range(lo,hi):
        factorials.append(f(n))

if __name__ == "__main__":
    hi = int(sys.argv[1]) + 1

    start = time.time()
    if hi > 1000:
        hi_1 = int(hi * 0.75)
        p1 = multiprocessing.Process(target=do_it, args=(fact,1,hi_1))
        p2 = multiprocessing.Process(target=do_it, args=(fact,hi_1,hi+1))
        p1.start()
        p2.start()
        p1.join()
        p2.join()
    else:
        do_it(fact, 1, hi)
        
    print('Time for %s: %s' % (hi, time.time() - start))

نلاحظ أننا أنشأنا كائنيْ Process، ومررنا الدالة التي نريد تشغيلها -وهي do_it- إضافةً إلى الوسائط اللازمة في صف tuple، ثم استدعينا start لتشغيل العمليات، أخيرًا استخدمنا التابع join لجعل البرنامج الرئيسي ينتظر انتهاء العمليات.

$ python3 processes.py 100
Time for 100: 0.0006771087646484375
$ python3 processes.py 1000
Time for 1000: 0.06577491760253906
$ python3 processes.py 10000
Time for 10000: 3.690302610397339

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

يبدو أن التزامن يعطينا تحسنًا كبيرًا في الأداء، لكن في الواقع لدينا خلل كبير في برنامجنا، فإذا طبعنا factorials -وهي قائمة النتائج- فسنجدها فارغةً!

والسبب في هذا أن كل عملية فرعية هي نسخة من العملية الأصل، وبالتالي لها نسختها الخاصة من قائمة factorials، والتي نفقد بياناتها عند انتهاء العملية، لذلك نحتاج إلى طريقة لتمرير البيانات إلى العملية الأصل، مما يعني الكتابة إلى ذاكرة مشتركة -انظر وحدة mmap- أو إلى قاعدة بيانات أو إلى ملف.

نستخدم في تلك الحالات كلها عمليات الإدخال والإخراج، لذا فلم لا نستخدم الخيوط بما أنها تتشارك الذاكرة! فنكون قد أنشأنا نسختنا الخاصة من معضلة Catch-22)!

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

استخدام الوحدة threading

سننشئ في هذا المثال خيطًا مساعِدًا لتحديث المتغير theTime في كل ثانية، وسيتكرر البرنامج الرئيسي بلا نهاية ليطبع المتغير في كل مرة يتغير فيها، ولضمان تشغيل الخيوط بسلاسة سنضيف تأخيرًا زمنيًا باستخدام time.sleep، التي يعاملها المفسر على أنها عملية إدخال/إخراج.

import time, threading

theTime = 0

def getTime():
    global theTime
    while True:
        theTime = time.time()
        time.sleep(1)

def main():
    global theTime
    current = theTime

    thrd = threading.Thread(target=getTime)
    thrd.start()

    while True:
        if current != theTime:
            current = theTime
            print(time.asctime(time.localtime(current)))
        time.sleep(0.01)

if __name == "__main__":
   main()

لقد أنشأنا في المثال أعلاه دالةً تغلف مهمة الخيوط، لضمان وجود عملية time.sleep فيها -أو أي دالة I/O أخرى-، ثم أنشأنا خيطًا نسند فيه دالتنا على أنها الهدف، كما فعلنا في العمليات أعلاه، ونبدأ تشغيل الخيط في الخلفية ثم ننتقل إلى الحلقة الأساسية التي تتحقق من المتغير في كل جزء من مئة من الثانية.

عند الحاجة إلى إنهاء البرنامج نكتب Ctrl+C أو نستخدم مدير المهام في نظام التشغيل لإنهاء هذه العملية.

إذا شغلنا الشيفرة السابقة فستكون النتيجة شبيهةً بما يلي:

$ python3 clock.py 
Sat Dec 30 11:30:33 2017
Sat Dec 30 11:30:34 2017
Sat Dec 30 11:30:35 2017
Sat Dec 30 11:30:36 2017
...

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

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

للمزيد من المعلومات، ننصحك بالإطلاع على دورة تطوير التطبيقات باستخدام لغة Python التي تشرح الكثير من المفاهيم الأساسية لبناء التطبيقات في بايثون.

خاتمة

نأمل في نهاية هذا المقال أن تكون تعلمت ما يلي:

• يُستخدم التزامن لتحسين الأداء.
• يُنفَّذ التزامن بتشغيل عمليات أو خيوط إضافية.
• تعمل العمليات بشكل مستقل عن بعضها، وتتواصل مع العملية الأصل باستخدام الأنابيب pipes.
• تعمل الخيوط افتراضيًا داخل العملية الأصل، وتتشارك الموارد -مثل الذاكرة وغيرها- فيما بينها.
• يجب إقفال الموارد المشتركة قبل تغيير الحالة لتجنب حدوث تعارضات.
• توجد طرق أخرى للتزامن، كما في وحدة asyncio في بايثون التي تستخدم منظورًا مختلفًا.

ترجمة -بتصرف- للمقال الثاني والثلاثين: Concurrent Programming من كتاب Learn To Program لصاحبه Alan Gauld.

اقرأ أيضًا

• المقال السابق: استخدام أطر العمل في برمجة تطبيقات الويب: فلاسك نموذجا
• برمجة عملاء ويب باستخدام بايثون
• كيفية كتابة تطبيقات الويب
• كيفية التعامل مع الويب
• استخدام أطر العمل في برمجة تطبيقات الويب: فلاسك نموذجًا

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

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

توجد الشيفرة الخاصة بهذا المقال في الملف survival.py، في مستودع الشيفرات ThinkStats2 على GitHub.

منحنيات البقاء

يُعَدّ منحني البقاء survival curve الذي يرمز له بـ S(t) المفهوم الأساسي في تحليل البقاء، كما يُعَدّ دالةً تحوِّل المدة t إلى احتمال البقاء أطول من t، ويُعَدّ حساب منحني البقاء سهلًا إذا علمت توزيع المدة أو مدة الحياة، حيث يمكن حساب المنحني عندها عن طريق حساب مكمل دالة التوزيع التراكمي كما يلي:

S(t)=1-CDF(t)

حيث يكون CDF(t) هو احتمال أن تكون مدة البقاء على قيد الحياة أقل أو تساوي t، ونعلم مثلًا في مجموعة بيانات المسح الوطني لنمو الأسرة مدة حالات الحمل التامة التي بلغ عددها 1189 حالة، حيث يمكننا قراءة هذه البيانات وحساب دالة التوزيع التراكمي كما يلي:

    preg = nsfg.ReadFemPreg()
    complete = preg.query('outcome in [1, 3, 4]').prglngth
    cdf = thinkstats2.Cdf(complete, label='cdf')

يدل رمز الخرج 1 على ولادة حية، ويدل رمز الخرج 3 على ولادة جنين ميت، في حين يدل رمز الخرج 4 على حالة إجهاض لا إرادية -أي غير متعمدة من قبل الأم-، كما استبعدنا حالات الإجهاض المتعمدة وحالات الحمل خارج الرحم وحالات الحمل التي كانت مستمرة أثناء مقابلة المستجيبة وذلك لأغراض هذا التحليل، كما يأخذ تابع إطار البيانات query تعبيرًا بوليانيًا ويقيّمه لكل سطر، ومن ثم يحدِّد الأسطر التي ينتج عنها قيمة True.

يوضِّح الشكل السابق دالة التوزيع التراكمي ومنحني البقاء لمدة الحمل في الأعلى؛ أما في الأسفل فيوضِّح منحني الخطر hazard curve، حيث عرّفنا كائنًا يغلِّف صنف Cdf وينفذ الواجهة:

class SurvivalFunction(object):
    def __init__(self, cdf, label=''):
        self.cdf = cdf
        self.label = label or cdf.label

    @property
    def ts(self):
        return self.cdf.xs

    @property
    def ss(self):
        return 1 - self.cdf.ps

يزودنا الصنف SurvivalFunction بخاصيتين اثنتين هما ts وهي تسلسل مدد الحياة وss التي هي منحني البقاء، إذ تُعَدّ الخاصية في لغة بايثون تابعًا يمكن استدعاؤه كما لو أنه متغير، كما يمكننا استنتاج الصنف SurvivalFunction عن طريق تمرير دالة التوزيع التراكمي لمدة الحياة كما يلي:

    sf = SurvivalFunction(cdf)

كما يزودنا الصنف SurvivalFunction بالدالتين __getitem__ وProb اللتين تقيّمان منحني البقاء.

# class SurvivalFunction

    def __getitem__(self, t):
        return self.Prob(t)

    def Prob(self, t):
        return 1 - self.cdf.Prob(t)

يُعَدّ sf[13] على سبيل المثال نسبة حالات الحمل التي تجاوزت الثلث الأول من الحمل:

>>> sf[13]
0.86022
>>> cdf[13]
0.13978

نرى أنّ 86‎%‎ من حالات الحمل تتجاوز الثلث الأول من الحمل؛ أما النسبة المتبقية 14‎‎%‎ فهي لا تتجاوز هذه المدة، كما يزودنا الصنف SurvivalFunction بالدالة Render التي ترسم sf باستخدام الدوال الموجودة في المكتبة thinkplot:

    thinkplot.Plot(sf)

يُظهر الشكل السابق الموجود في الأعلى النتيجة، حيث يكون المنحني مسطحًا تقريبًا بين الأسبوعين 13 و26، مما يدل على أن عدد قليل من حالات الحمل تنتهي في الثلث الثاني من الحمل، ويكون المنحني أكثر حدةً عند حوالي 39 أسبوعًا وهي أكثر فترات الحمل شيوعًا.

دالة الخطر

يمكننا اشتقاق دالة الخطر hazard function من منحني البقاء، حيث تُعَدّ دالة الخطر لمدة الحمل دالةً تحوِّل الزمن t إلى نسبة حالات الحمل التي تستمر حتى المدة t ومن ثم تنتهي عند t، ونقول بصورة أدق:

يُعَدّ البسط نسبة مدة الحياة التي تنتهي عند t وهي تمثِّل أيضًا دالة الكثافة الاحتمالية عند t أي PMF(t)، كما يزودنا الصنف SurvivalFunction بالدالة MakeHazard التي تحسب دالة الخطر:

# class SurvivalFunction

    def MakeHazard(self, label=''):
        ss = self.ss
        lams = {}
        for i, t in enumerate(self.ts[:-1]):
            hazard = (ss[i] - ss[i+1]) / ss[i]
            lams[t] = hazard

        return HazardFunction(lams, label=label)

حيث يُعَدّ الكائن HazardFuntion مغلِفًا لسلسلة بانداز:

class HazardFunction(object):

    def __init__(self, d, label=''):
        self.series = pandas.Series(d)
        self.label = label

قد يكون d قاموسًا أو أيّ نوع آخر قادر على استنساخ سلسلة تتضمن سلسلةً أخرى، في حين يكون label سلسلةً نصيةً مستخدَمةً لتحديد HazardFunction عند رسمه، كما يزودنا HazardFunction بالدالة __getitem__، وبالتالي يمكننا تقييمه كما يلي:

>>> hf = sf.MakeHazard()
>>> hf[39]
0.49689

لذا تنتهي حوالي ‎50% من بين جميع حالات الحمل التي تستمر حتى الأسبوع 39 في الأسبوع 39.

يُظهر الشكل السابق الموجود في الأسفل دالة الخطر hazard function لمدة الحمل، كما نرى أنّ دالة الخطر بعد الأسبوع 42 تصبح غير منتظمة لأنها مبنية على عدد صغير من الحالات، لكن بخلاف ذلك يكون شكل المنحني كما هو متوقع، بحيث يبلغ ذروته عند الأسبوع 30 تقريبًا ويصبح في الثلث الأول أعلى من الثلث الثاني، كما تُعَدّ دالة الخطر مفيدةً لوحدها، لكنها أيضًا أداةً مهمةً لتقدير منحنيات البقاء كما سنرى في القسم التالي.

استنتاج منحنيات البقاء

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

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

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

1. سينتج عن هذا مبالغة في تمثيل النساء الأكبر عمرًا، لأنه من المرجح أن تكون هذه الفئة متزوجة أثناء إجراء المسح.
2. سينتج مبالغة في تمثيل النساء المتزوجات.

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

تقدير كابلان ماير

ليس من المفضل في هذا المثال تضمين حالات النساء غير المتزوجات وإنما هو أمر ضروري، وهو ما يقودنا إلى إحدى الخوارزميات الأساسية في تحليل البقاء والتي هي تقدير كابلان ماير Kaplan-Meier estimation.

تستند الفكرة العامة على استخدام البيانات لتقدير دالة الخطر ومن ثم تحويل دالة الخطر إلى منحني البقاء، وإذا أردنا تقدير تابع الخطر، فيمكننا من أجل كل عمر الأخذ في الحسبان: (1) عدد النساء اللواتي تزوجن في هذا العمر و(2) عدد النساء "المعرضات لخطر" الزواج، وهذا يتضمن النساء اللواتي لم يتزوجن من قبل، وإليك الشيفرة الموافقة كما يلي:

def EstimateHazardFunction(complete, ongoing, label=''):

    hist_complete = Counter(complete)
    hist_ongoing = Counter(ongoing)

    ts = list(hist_complete | hist_ongoing)
    ts.sort()

    at_risk = len(complete) + len(ongoing)

    lams = pandas.Series(index=ts)
    for t in ts:
        ended = hist_complete[t]
        censored = hist_ongoing[t]

        lams[t] = ended / at_risk
        at_risk -= ended + censored

    return HazardFunction(lams, label=label)

تُعَدّ complete أنها الحالات الكاملة التي رُصِدَت، وتكون في مثالنا هذا أعمار المستجيبات عندما تزوجن، في حين تُعَدّ ongoing أنها الحالات غير الكاملة وهي أعمار النساء غير المتزوجات في المسح.

نحسب بدايةً hist_complete، وهو دالة عدادة Counter تحوِّل العمر إلى عدد النساء المتزوجات في هذا العمر، كما نحسب hist_ongoing هو دالة عدادة Counter تحوِّل العمر إلى عدد النساء غير المتزوجات اللواتي قوبِلن في ذلك العمر؛ أما ts فهو اجتماع الأعمار التي تزوجت فيها المستجيبات والأعمار التي قوبلت فيها النساء غير المتزوجات مرتبًا ترتيبًا تصاعديًا، كما تتتبّع at_risk عدد المستجيبات المعرضات للخطر في كل عمر وهو العدد الكلي للمستجيبات، وتُخزن النتيجة في سلسلة Series بانداز Pandas والتي تحول كل عمر إلى دالة الخطر المقدَّرة في ذلك العمر.

نتعامل في كل مرور على الحلقة مع عمر واحد t ونحسب عدد الأحداث التي تنتهي عند t -أي عدد المستجيبات المتزوجات عند هذا العمر- وعدد الأحداث التي أوقِفت عند t -أي عدد النساء اللواتي قوبِلن عند t ولكن تواريخ زواجهن المستقبلية موقفة censored- ويشير مصطلح "أوقف" إلى أنّ البيانات غير متاحة بسبب عملية جمع البيانات، كما تُعَدّ دالة الخطر المُقدَّرة بأنها نسبة الحالات المعرَّضة للخطر والتي تنتهي عند t، ونطرح في نهاية الحلقة من at_risk عدد الحالات التي انتهت أو أوقفت عند t، ثم نمرِّر في النهاية lams إلى الباني HazardFunction ونُعيد النتيجة.

منحني الزواج

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

• cmbirth: يوم ميلاد كل مستجيبة وهو معلوم في كل الحالات.
• cmintvw: تاريخ مقابلة كل مستجيبة وهو معلوم في كل الحالات.
• cmmarrhx: تاريخ أول حالة زواج للمستجيبة إذا كانت متزوجةً وكان التاريخ معلومًا.
• evrmarry: قيمة هذا المتغير 1 إذا كانت المستجيبة قد تزوجت قبل تاريخ المقابلة و0 بخلاف ذلك.

حيث أن المتغيرات الثلاثة الأولى مرمَّزة بنظام أشهر القرن وهو العدد الصحيح للأشهر منذ شهر 12 من عام 1899، أي يكون شهر القرن 1 هو شهر 1 من عام 1900، وسنقرأ في البداية ملف المستجيبات ونستبدل قيم cmmarrhx غير الصالحة كما يلي:

    resp = chap01soln.ReadFemResp()
    resp.cmmarrhx.replace([9997, 9998, 9999], np.nan, inplace=True

ثم نحسب عمر كل مستجيبة عند الزواج وعند مقابلتها:

    resp['agemarry'] = (resp.cmmarrhx - resp.cmbirth) / 12.0
    resp['age'] = (resp.cmintvw - resp.cmbirth) / 12.0

ثم نستخرِج complete وهو عمر النساء المتزوجات عند زواجهن واللاتي لم تزلن متزوجات، وongoing وهو عمر النساء اللاتي لا يحققن ما سبق أثناء المقابلة:

    complete = resp[resp.evrmarry==1].agemarry
    ongoing = resp[resp.evrmarry==0].age

سنحسب أخيرًا دالة الخطر:

    hf = EstimateHazardFunction(complete, ongoing)

يُظهر الشكل 13.2 (الموجود في الجهة العليا) دالة الخطر المُقدَّرة، وهي منخفضة في فترة المراهقة ومرتفعة في العشرينات من العمر وتنخفض في الثلاثينات وتعود لترتفع في الأربعينات، لكن هذا ناتج عملية التقدير، حيث سينتج عن زواج عدد صغير من النساء خطرًا مقدَّرًا كبيرًا مع نقصان المستجيبات لمعرضات للخطر، لكن سيخفف منحني البقاء من هذا الضجيج.

تقدير منحني البقاء

يمكننا تقدير منحني البقاء عند حصولنا على دالة الخطر، حيث أنّ فرصة البقاء بعد الوقت t هو فرصة البقاء لكل الأوقات بدءًا من بداية الرصد حتى t، وهو ناتج الجداء التراكمي لدالة الخطر المكملة:

يزودنا الصنف HazardFunction بالدالة MakeSurvival التي تحسب هذا الجداء:

# class HazardFunction:

    def MakeSurvival(self):
        ts = self.series.index
        ss = (1 - self.series).cumprod()
        cdf = thinkstats2.Cdf(ts, 1-ss)
        sf = SurvivalFunction(cdf)
        return sf

حيث أنّ ts هو تسلسل الأوقات التي قُدِّرت فيها دالة الخطر، وss هو ناتج الجداء التراكمي لدالة الخطر المكملة، وبالتالي فهو منحني البقاء، كما يتوجب علينا حساب مكمل ss ومن ثم إنشاء Cdf واستنساخ كائن SurvivalFunction وذلك بسبب الطريقة التي يُنفَّذ بها SurvivalFunction.

يوضَّح الشكل السابق الموجود في الأعلى دالة الخطر لعمر أول زواج؛ أما الذي في الأسفل فيوضَّح منحني البقاء، كما يُظهر الشكل السابق الموجود في الأسفل النتيجة، حيث يكون منحني البقاء أكثر حدةً بين العمرين 25 و35، وهو المدى الذي تتزوج فيه معظم النساء؛ أما بين العمرين 35 و45 فيكون المنحني مسطحًا تقريبًا، مما يشير إلى أنه من غير المرجح زواج النساء اللواتي لم يتزوجن قبل سن الخامس والثلاثين.

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

فواصل الثقة

ينتج عن تحليل كابلان-ماير تقديرًا واحدًا لمنحني البقاء ولكنه مهم لحساب عدم اليقين الناتج عن التقدير، كما توجد ثلاثة مصادر محتملة للخطأ على أساس العادة وهي خطأ القياس measurement error وخطأ أخذ العينات sampling error وخطأ النمذجة modeling error، حيث يُعَدّ خطأ القياس في هذا المثال صغيرًا غالبًا، أي يعلم الأشخاص التاريخ الصحيح لولادتهم وإن كانوا قد تزوجوا بالإضافة إلى تاريخ الزواج، ويفترض أنهم قدَّموا هذه المعلومات بدقة، وإليك الشيفرة التي تحسب خطأ أخذ العينات عن طريق تطبيق إعادة أخذ العينات:

def ResampleSurvival(resp, iters=101):
    low, high = resp.agemarry.min(), resp.agemarry.max()
    ts = np.arange(low, high, 1/12.0)

    ss_seq = []
    for i in range(iters):
        sample = thinkstats2.ResampleRowsWeighted(resp)
        hf, sf = EstimateSurvival(sample)
        ss_seq.append(sf.Probs(ts))

    low, high = thinkstats2.PercentileRows(ss_seq, [5, 95])
    thinkplot.FillBetween(ts, low, high)

تأخذ الدالة ResampleSurvival الوسيطَين resp وهو إطار بيانات المستجيبين وiters وهو عدد المرات التي يجب فيها إعادة أخذ العينات، ومن ثم تحسب ts وهو تسلسل الأعمار وهنا سنقيِّم منحني البقاء، كما تقوم الدالة ResampleSurvival بالخطوات التالية ضمن الحلقة:

• تعيد أخذ عينات المستجيبين باستخدام ResampleRowsWeighted، ورأينا هذا في قسم إعادة أخذ العينات مع الأوزان في مقال المربعات الصغرى الخطية في بايثون.
• تستدعي EstimateSurvival التي تستخدِم العملية الموجودة في الأقسام السابقة بهدف تقدير منحني البقاء ومنحني الخطر.
• ثم تقيِّم منحني البقاء في كل عمر في ts.

يُعَدّ ss_seq تسلسل منحنيات البقاء المقدَّرة، كما تأخذ الدالة PercentileRows هذا التسلسل وتحسب المئين الخامس والمئين الخامس والتسعين وتعيد فاصل الثقة 90‎%‎ الخاص بمنحني البقاء.

يوضِّح الشكل السابق منحني البقاء للعمر عند أول زواج الممثَّل بالخط الداكن وفاصل الثقة ‎90% المبني على إعادة أخذ العينات مع الأوزان والممثَّل بالخط الرمادي، كما يظهر الشكل السابق النتيجة ومنحني البقاء الذي قدَّرناه في القسم السابق، ويأخذ فاصل الثقة أوزان أخذ العينات بالحسبان على عكس المنحني المقدَّر الذي لا يضع الأوزان في حسبانه، علمًا أنَّ التناقض بينهما يشير إلى التأثير الكبير لأوزان أخذ العينات على التقدير وعلينا أخذ ذلك في الحسبان.

تأثيرات الفوج

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

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

جمعنا بيانات الدورة السادسة من 2002 المستخدَمة في هذه السلسلة وبيانات الدورة السابعة من 2006-2010 المستخدَمة في قسم التكرار في مقال اختبار الفرضيات الإحصائية وبيانات الدورة الخامسة من 1995، حيث تحوي مجموعة البيانات كلها 30769 مستجيبةً، وذلك من أجل البحث في تأثيرات الفوج في بيانات الزواج في المسح الوطني لنمو الأسرة.

    resp5 = ReadFemResp1995()
    resp6 = ReadFemResp2002()
    resp7 = ReadFemResp2010()
    resps = [resp5, resp6, resp7]

استخدمنا cmbirth من أجل كل إطار بيانات resp لحساب عقد ولادة كل مستجيبة:

    month0 = pandas.to_datetime('1899-12-15')
    dates = [month0 + pandas.DateOffset(months=cm) 
             for cm in resp.cmbirth]
    resp['decade'] = (pandas.DatetimeIndex(dates).year - 1900) // 10

حيث أن المتغير cmbirth مرمَّز ليدل على العدد الصحيح للأشهر التي مضت منذ شهر 12 من عام 1899، فتمثِّل month0 هذا التاريخ على أساس كائن ختم زمني Timestamp، كما نستنسخ DateOffset من أجل كل تاريخ ميلاد والذي يحتوي على أشهر القرن ونضيفه إلى month0 لتكون النتيجة تسلسلًا من الأختام الزمنية TimeStamps التي يجري تحوَّل إلى النوع DateTimeIndex، ونستخرج أخيرًا year الذي يمثِّل السنة ونحسب decades الذي يمثِّل العقد.

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

    for i in range(iters):
        samples = [thinkstats2.ResampleRowsWeighted(resp) 
                   for resp in resps]
        sample = pandas.concat(samples, ignore_index=True)
        groups = sample.groupby('decade')

        EstimateSurvivalByDecade(groups, alpha=0.2)

تستخدِم بيانات الدورات الثلاثة للمسح الوطني لنمو الأسرة أوزانًا مختلفةً، لذا أعدنا أخذ عينات كل منها على حدة ثم استخدمنا concat لدمجها لتصبح إطار بيانات واحد، علمًا أنّ المعامِل ignore_index يشير إلى concat لكي لا يطابق المستجيبين حسب الفهرس وإنما ينشئ فهرسًا جديدًا من 0 إلى 30768، كما ترسم الدالة EstimateSurvivalByDecade منحنيات بقاء كل فوج.

def EstimateSurvivalByDecade(resp):
    for name, group in groups:
        hf, sf = EstimateSurvival(group)
        thinkplot.Plot(sf)

يوضِّح الشكل السابق منحنيات بقاء المستجيبات اللواتي ولدن ضمن عقود مختلفة، كما يظهر الشكل السابق النتائج ونرى عدة أنماط فيه وهي:

• النساء اللواتي ولدن في الخمسينيات هم أكثر من تزوج في عمر صغير، وكذلك فإن أفراد الفوج التالي تزوجن في عمر متأخر أكثر، والفوج التالي بعد الفوج السابق وهكذا، وبقوا على الأقل حتى عمر الثلاثين تقريبًا.
• تملك النساء اللواتي ولدن في ستينيات القرن الماضي نمطًا غريبًا، إذ تزوجت النساء هنا في عمر 25 بمعدل أبطأ من الفوج السابق، ولكن بعد عمر 25 أصبح معدل الزواج أسرع، لكن النساء في هذا الفوج تجاوزت فوج الخمسينيات عند عمر 32، واتضح أنَّ احتمال زواج النساء في عمر 44 هو المرجَّح، لكن النساء اللواتي ولدن في الستينيات بلغن عمر 25 بين عامَي 1985 و1995، ومن المغري اعتقاد أنّ المقال الذي ذكرناه منذ قليل قد تسبب في ازدياد حالات الزواج، لكنه تفسير رديء للغاية، ومع ذلك فإنه من المحتمل أن يكون المقال وردّ الفعل عليه مؤشرَين على حالة مزاجية أثرت على سلوك هذا الفوج.
• يملك فوج السبعينات نمطًا مشابهًا، حيث أن النساء هنا أقل احتمالًا لأن يتزوجن قبل عمر 25 إذا وازناه مع الأفواج السابقة، لكن هذا لهذا الفوج احتمالات مشابهة للأفواج السابقة فيما يخص الزواج عند عمر 35.
• احتمال أن زواج فوج الثمانينيات قبل 25 هو أقل من الفوج السابق، ولكن ما يحدث بعد ذلك هو غير واضح، وإذا أردنا بيانات أكثر، فعلينا الانتظار حتى الدورة التالية من المسح الوطني لنمو الأسرة.

يمكننا توليد بعض التنبؤات ريثما تصلنا البيانات.

الاستقراء الخارجي Extrapolation

ينتهي منحني البقاء لفوج السبعينات عند عمر 38 تقريبًا؛ أما فوج الثمانينات فينتهي منحني البقاء الخاص به عند سن 28، وبالطبع فإن بيانات فوج التسعينات نادرة جدًا، كما يمكننا استقراء هذه المنحنيات خارجيًا عن طريق استعارة بيانات من الفوج السابق، حيث يزودنا الصنف HazardFunction بالتابع Extend الذي ينسخ الذيل من HazardFunction أطول كما يلي:

# class HazardFunction

    def Extend(self, other):
        last = self.series.index[-1]
        more = other.series[other.series.index > last]
        self.series = pandas.concat([self.series, more])

يحتوي HazardFunction على سلسلة تحوِّل الوقت t إلى λ(t)، ويجد التابع Extend المتغير last وهو الفهرس الأخير في self.series،ثم يختار قيم من other التي تأتي بعد last ويضيفها إلى نهاية self.series، ويمكننا الآن توسيع HazardFunction الخاص بكل فوج وذلك بالاستعانة بقيم من الفوج السابق:

def PlotPredictionsByDecade(groups):
    hfs = []
    for name, group in groups:
        hf, sf = EstimateSurvival(group)
        hfs.append(hf)

    thinkplot.PrePlot(len(hfs))
    for i, hf in enumerate(hfs):
        if i > 0:
            hf.Extend(hfs[i-1])
        sf = hf.MakeSurvival()
        thinkplot.Plot(sf)

حيث أن groups هو كائن GroupBy فيه معلومات المستجيبات مصنفة إلى مجموعات حسب عقد الولادة، كما تحسب الحلقة الأولى HazardFunction كل مجموعة، في حين توسِّع الحلقة الثانية كل HazardFunction بقيم من الفوج السابق له والذي قد يحتوي على قيم من المجموعة التي تسبقه أيضًا (أي قد يحتوي فوج الخمسينات على قيم من فوج الأربعينات وقد يحتوي فوج الأربعينات على قيم من فوج الثلاثينات وهكذا)، ثم تحوِّل كل HazardFunction إلى SurvivalFunction وترسمه.

يوضِّح الشكل السابق منحنيات البقاء الخاصة بالمستجيبات اللواتي ولدن خلال عقود مختلفة، مع تنبؤات للأفواج اللاحقة، كما يُظهر الشكل السابق النتائج، وقد حذفنا فوج الخمسينات لجعل التنبؤات أكثر وضوحًا، وتقترح هذه النتائج أنه بحلول السن الأربعين ستتقارب الأفواج الأحدث مع فوج الستينيات وستمثل المستجيبات المتزوجات نسبةً تقل عن %20 من المجموع الكلي.

العمر المتبقي المتوقع

إذا كان لدينا منحني بقاء، فيمكننا حساب العمر المتبقي المتوقع على أساس دالة للعمر الحالي، أي إذا كان لدينا مثلًا منحني البقاء لطول الحمل من القسم الأول من هذا المقال، فيمكننا حساب الوقت المتوقع حتى حدوث المخاض والولادة، حيث تتمثل الخطوة الأولى في استخراج دالة الكثافة الاحتمالية PMF للأعمار، كما يزودنا الصنف SurvivalFunction بالتابع الذي يقوم بالمطلوب:

# class SurvivalFunction

    def MakePmf(self, filler=None):
        pmf = thinkstats2.Pmf()
        for val, prob in self.cdf.Items():
            pmf.Set(val, prob)

        cutoff = self.cdf.ps[-1]
        if filler is not None:
            pmf[filler] = 1-cutoff

        return pmf

تذكر أنّ SurvivalFunction تحتوي على Cdf للعمر، وتنسخ الحلقة القيم والاحتمالات من Cdf إلى Pmf، كما تُعَدّ cutoff هي أعلى احتمال في Cdf، وهي 1 إذا كان Cdf كاملًا وأقل من 1 بخلاف ذلك، وإذا كان Cdf غير كامل، فسنُدخل القيمة المزوَّدة إلى filter لنكملها، لكن يُعَدّ Cdf لمدة الحمل كاملًا، لذا لا داع للقلق حول هذا الأمر؛ أما الخطوة التالية هنا فهي حساب العمر المتبقي المتوقع، حيث يعني المتوقع هنا المتوسط الحسابي، كما يزودنا SurvivalFunction بدالة تقوم بهذا أيضًا:

# class SurvivalFunction

    def RemainingLifetime(self, filler=None, func=thinkstats2.Pmf.Mean):
        pmf = self.MakePmf(filler=filler)
        d = {}
        for t in sorted(pmf.Values())[:-1]:
            pmf[t] = 0
            pmf.Normalize()
            d[t] = func(pmf) - t

        return pandas.Series(d)

تأخذ RemainingLifetime الوسيط filterالذي يمرَّر إلى MakePmf وfunc وهو الدالة المستخدَمة لتلخيص توزيع العمر المتبقي؛ أما pmf فهي Pmf الأعمار المتبقية المستخرَجة من SurvivalFunction، وd هو قاموس يحتوي على النتائج وهو تحويل من العمر الحالي t إلى العمر المتبقي المتوقع.

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

يوضِّح الشكل السابق مدة الحمل المتوقعة المتبقية في الجهة اليسرى؛ أما في الجهة اليمنى فيوضِّح السنوات حتى أول زواج، كما يُظهر الشكل السابق في الجهة اليسرى طول الحمل المتبقي المتوقع على أساس دالة للمدة الحالية، أي المدة المتبقية المتوقعة في الأسبوع 0 مثلًا هي حوالي 34 أسبوع، وهي أقل من طول الحمل الكامل -أي 39 أسبوع- لأن حالات الإجهاض التي حصلت في الثلث الأول قد خفضت من المتوسط.

ينخفض المنحني ببطء في الثلث الأول، وتكون المدة المتبقية المتوقعة بعد 13 أسبوع قد انخفضت 9 أسابيع لتصبح 25 أسبوع، بعد ذلك ينخفض بسرعة أكبر، وذلك بمعدل انخفاض أسبوع كامل في كل أسبوع جديد، في حين ينخفض المنحني حوالي أسبوع أو أسبوعين في الفترة ما بين الأسبوع 37 والأسبوع 42، وتكون المدة المتبقية المتوقعة في هذه الفترة ثابتةً، أي لا تصبح الوجهة أقرب مع مرور الأسابيع، وتدعى العمليات التي تحمل هذه الخاصية بعمليات بلا ذاكرة memoryless لأن ليس للماضي تأثير على التنبؤات، علمًا أنّ هذا السلوك هو الأساس الرياضي لجملة الممرضات الشهيرة التي تثير الغضب: اقترب موعد الولادة ومتوقع أن تلدي في أيّ يوم الآن.

يُظهر الشكل السابق في الجهة اليمنى الوقت الوسيط المتبقي حتى أول زواج على أساس دالة للعمر، حيث يكون الوسيط هو 14 عامًا بالنسبة لفتاة عمرها 11 عامًا، ويقل المنحني حتى عمر 22 حينما يصبح الوقت المتبقي الوسيط هو حوالي 7 سنوات، ويزداد مرةً أخرى بعدها وبحلول العمر 30 يعود إلى ما كان عليه أي 14 عامًا، ويمكننا استنادًا إلى هذه البيانات استنتاج أنّ للنساء صغيرات السن أعمارًا متبقيةً متناقصةً، وتدعى المكونات الميكانيكية المرتبطة بهذه الخاصية NBUE وهي اختصار لمِن المتوقع أن يكون الجديد أفضل من المستخدَم new better than used in expectation، أي من المتوقع بقاء الجزء الجديد فترةً أطول.

تملك النساء اللواتي تجاوزت أعمارهن 22 سنة وقتًا متبقيًا متزايدًا حتى أول زواج، وتدعى المكونات الميكانيكية المرتبطة بهذه الخاصية UBNE وهي اختصار لمِن المتوقع أن يكون المستخدَم أفضل من الجديد used better than new in expectation، أي من المتوقع أن يبقى الجزء المستخدَم فترةً أطول، إذ يُعَدّ الأطفال حديثو الولادة مثلًا ومرضى السرطان هم UBNE أيضًا لأن العمر المتوقع لديهم يزيد كلما طالت مدة حياتهم، فقد حسبنا الوسيط median في هذا المثال بدلًا من المتوسط mean لأن Cdf غير كامل، ويتوقع منحني البقاء أن نسبة ‎20% من المستجيبات لن يتزوجن قبل سن 44، وبما أن سن الزواج الأول لهؤلاء النساء غير معلوم وقد يكون غير موجود، فلن نتمكن من حساب المتوسط.

استبدلنا القيم غير المعلومة هنا بالقيمة np.inf وهي قيمة خاصة تمثِّل اللانهاية، أي أنها تجعل متوسط اللانهاية لكل الاعمار، لكن يبقى الوسيط محدَّدًا تمامًا طالما أنّ أكثر من 50‎%‎ من الأعمار المتبقية نهائية، وهذا صحيح حتى عمر الثلاثين؛ أما بعدها فمن الصعب تحديد عمر متبقي متوقع له، وإليك الشيفرة التي تحسب وترسم هذه الدوال:

    rem_life1 = sf1.RemainingLifetime()
    thinkplot.Plot(rem_life1)

    func = lambda pmf: pmf.Percentile(50)
    rem_life2 = sf2.RemainingLifetime(filler=np.inf, func=func)
    thinkplot.Plot(rem_life2)

حيث أن sf1 هو منحني البقاء لطول الحمل، ويمكن في هذه الحالة استخدام القيم الافتراضية للدالة RemainingLifetime؛ أما sf2 فهو منحني البقاء للعمر عند أول زواج، وfunc هو دالة تأخذ Pmf وتحسب وسيطها -أي المئين رقم 50-.

تمارين

يوجد الحل الخاص بهذا التمرين في chap13soln.py في مستودع الشيفرات ThinkStats2 على GitHub (وسائر ملفات التمارين).

تمرين 1

يحتوي المتغير cmdivorcx في الدورتين السادسة والسابعة من المسح الوطني لنمو الأسرة على تاريخ طلاق المستجيبين من أول حالة زواج، وهي مرمَّزة بطريقة أشهر القرن.

اقتباس

توضيح: يوفِّر نظام أشهر القرن طريقةً سهلةً للعمل مع البيانات المرمزة حسب الشهر والسنة، وهي الطريقة الأساسية ترمَّز بها التواريخ في المسوح السكانية والصحية.

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

ترجمة وبتصرف للمقال Chapter 13 Survival analysis analysis من كتاب Think Stats: Exploratory Data Analysis in Python.

اقرأ أيضًا

• الانحدار الإحصائي regression ودوره في ملاءمة النماذج المختلفة مع أنواع البيانات المتاحة
• نمذجة التوزيعات Modelling distributions في بايثون
• تحليل البيانات الاستكشافية لإثبات النظريات الإحصائية

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

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

سنغطي في هذا المقال من سلسلة تعلم البرمجة:

• تاريخ موجز لخوادم الويب.
• أساسيات CGI: واجهة البوابة المشتركة.

مقدمة في برمجة خوادم الويب

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

ثم صرنا ندمج البرامج في خوادم الويب لتوليد الصفحات ديناميكيًا كلما طلبها المستخدم، وسميت الآلية المستخدمة في ذلك واجهة البوابة المشتركة Common Gateway Interface أو CGI اختصارًا، ولا يزال أثر تلك التقنية باقيًا في مواقع الويب التي نتصفحها حاليًا.

ومع استغلال المبرمجين إمكانيات واجهة CGI -مع وسم <form> في HTML- صارت المواقع التي يبنونها أكثر تطورًا وتعقيدًا، وصار من الممكن بناء مواقع التسوق الإلكتروني، والألعاب، والدعم الفني، وغيرها من الخدمات التي صارت اليوم بدهيات.

تُبنى واجهة CGI على مفهوم بسيط، هو أن بيانات الإدخال تُرسَل مثل جزء من رسالة http GET أو http POST، ويشير الرابط إلى مجلد خاص في خادم الويب، الذي يعرف أن عليه تنفيذ المورد resource بدلًا من إعادته، وهذا المورد هو برنامج يرسل الخرج الخاص به إلى مجرى الخرج القياسي stdout في صفحة HTML، فيقرأ الخادم مجرى الخرج القياسي، ويوجهه إلى العميل الذي طلب الصفحة.

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

إنشاء صفحة ترحيب باستخدام واجهة CGI

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

صفحة ويب بسيطة

أول ما علينا فعله هو إنشاء صفحة الويب التي نريد إرسالها، ولن نشرح كيفية كتابة شيفرة HTML بالتفصيل هنا، وإنما سنشرح ما يكفي لتشغيل الأمثلة التي نكتبها، وستبدو صفحة "Hello World" بسيطةً كما يلي:

<!doctype html>
<html>
   <head>
     <title>Hello world web page</title>
   </head>
   <body>
       <h1>Hello World</h1>
   </body>
</html>

تتكون HTML من وسوم، وهي أسماء محددة مسبقًا في توصيف اللغة نفسها، تحيط بها علامتا < و>، وتأتي أغلب الوسوم في أزواج يكون وسم الإغلاق فيها مسبوقًا بشرطة مائلة /، كما قد تحتوي الوسوم على بيانات تُعرف بالخاصيات attributes، غير أن المثال أعلاه ليس فيه أي منها لأننا بدأنا به بسيطًا، لكننا سنراها لاحقًا.

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

1. التصريح doctype: يشير إلى أن هذا المستند هو مستند HTML، وقد كان هذا التصريح طويلًا ومفصلًا سابقًا، لكن -ومنذ صارت HTML5 قياسيةً ومعتمدةً- نكتفي بكتابة html في ذلك التصريح. لاحظ أن تنسيق الوسم في doctype مختلف عن وسوم HTML العادية، إذ توجد علامة تعجب مباشرةً بعد علامة ‎<‎.
2. الوسم html: نستخدم زوجًا من الوسم <html> لتحديد بداية متن المستند نفسه ثم وسم إغلاق له، ويشكل هذا الوسم جذر المستند، وتمثَّل صفحات HTML في ذاكرة المتصفح في هيكل شجري، تكون قمته الوسم <html>. وتعدِّل شيفرة جافاسكربت التي في المتصفح ذلك الهيكل، لذا تؤثر طريقة كتابة HTML كثيرًا في كيفية كتابة شيفرة جافاسكربت، وكذلك في قراءة عملاء الويب web clients -مثل تلك التي كتبناها في المقال السابق- لتلك الصفحة.
3. الوسم head: يحدد الوسم <head> جزءًا من الصفحة يحوي معلومات عن الصفحة نفسها، لكن المتصفح لا يعرضها، فمثلًا تعرَّف فيه بيانات أوراق الأنماط المتتالية أو التنسيقات الموروثة CSS، وقد يُستورد ملف CSS عند وجود عدة أنماط في الصفحة، كما تستورد ملفات جافاسكربت المستخدَمة في الصفحة. نلاحظ أننا أزحنا الوسوم في المثال أعلاه، لكن ذلك لا يؤثر على تنفيذ الشيفرة، وهو لتحسين قراءة الشيفرة وإظهار الهيكل الشجري المتشعب للمستند لا أكثر، ولا فرق بالنسبة للمتصفح سواء أزيحت الشيفرة أم لا، وقسم head غير إلزامي عند كتابة مستندات HTML نظريًا، لكن وجوده يرجع إلى حاجة أغلب المتصفحات الحديثة للمعلومات التي فيه.
4. الوسم title: يحتوي هذا الوسم على عنوان الصفحة الذي سيعرضه المتصفح، وهو الجزء الوحيد المعروض من قسم الترويسة، رغم تأثير الأنماط وجافاسكربت في المظهر العام لمحتوى الصفحة الرئيسية.
5. الوسم body: يغلف هذا الوسم المحتوى الأساسي للصفحة، والذي نراه في نافذة المتصفح.

هذه هي العناصر الأساسية لصفحة الويب، وقد استخدمنا الوسم <h1> الذي يحتوي رسالة "Hello World"، وهو جزء من مجموعة عناصر h -التي تشير إلى كلمة ترويسة header- وتُرقَّم من 1 إلى 6 لتوضح ترتيب عناوين الفقرات، ويصغر حجم الخط المستخدم ومظهره كلما اقتربنا من العنوان السادس، رغم إمكانية تعديل ذلك باستخدام CSS.

نحفظ شيفرة HTML في مستند باسم index.htm في مجلد باسم hello، ونتحقق من عمله بتحميله في متصفح ويب، فإذا عرض المتصفح الصفحة كما نريدها فنكون قد نجحنا في هذه المهمة البسيطة، وننتقل الآن إلى توفيره من خلال خادم الويب الخاص بنا.

تشغيل خادم الويب

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

$ python -m http.server --cgi 8000

يحدد الخيار ‎-m في الشيفرة أعلاه الوحدة التي يجب أن تشغلها بايثون، أما الراية ‎--cgi فتفعّل عمليات واجهة CGI التي سنحتاج إليها لاحقًا، ويشير العدد 8000 إلى منفذ الشبكة الذي ستستخدمه.

تحميل صفحة الويب

نستطيع الآن الوصول إلى الخادم من خلال تحميل الرابط التالي في شريط عنوان المتصفح:

http://localhost:8000

إذا كان الخادم يعمل فستحمَّل تلك الصفحة وتُعرض كما فعلنا من قبل، إلا أنها الآن تُرسَل من قبل الخادم، كما يتضح من شريط العنوان في المتصفح، وبهذا نكون قد أرسلنا أول صفحة ويب لنا!

والسبب الذي يجعل هذه العملية ناجحةً دون تحديد اسم الملف هو أن خوادم الويب تبحث عن ملف باسم index.htm تلقائيًا، فإذا كان موجودًا ولم نحدّد ملفًا مسبقًا فسيُعرض index.htm. كما يمكن إعداد الخادم ليبحث عن ملفات افتراضية أخرى، مثل index.html أو index.php.

استخدام واجهة CGI لعرض رسالة ترحيب بالمستخدم

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

إنشاء استمارة HTML

الخطوة الأولى لذلك هي تعديل ملف HTML ليتضمن حقل إدخال لاسم المستخدم، كما يلي:

<!doctype html>
<html>
  <head>
    <title>Hello user page</title>
  </head>
  <body>
    <h1>Hello, welcome to our website!</h1>
    <form name="hello" 
          method="get" 
          action="http://localhost:8000/cgi-bin/sayhello.py">
      <p>Please tell us your name:</p>
      <input type="text" id="username" name="username" 
             size="30" required autofocus/>
      <input type="submit" value="Submit" />
    </form>
  </body>
</html>

نلاحظ هنا أن عناصر <form> تحتوي على خاصيات في وسومها، حيث تشكل الخاصية name جزءًا من البيانات المرسَلة إلى الخادم مع القيمة التي في صندوق الإدخال النصي، وتخبر الخاصية method الخاصة بوسم form المتصفح نوع رسالة http التي يجب إرسالها -وهي GET في هذه الحالة-، كما تخبره الخاصية action بالمكان الذي يجب أن يرسلها إليه.

تخبر خاصيتا العنصر input الأخيرتان المتصفح ألا يرسل الاستمارة إلا إذا احتوى الحقل النصي على قيمة، وأن يضع المؤشر في ذلك الحقل ليكون مستعدًا لاستقبال الإدخال، كما تخبر القيمة submit الموجودة في نوع الإدخال type المتصفح أن يعرض هذا العنصر مثل زر تظهر عليه الكلمة الموجودة في قيمة الخاصية value -والتي هي submit أيضًا-، وسيرسل ذلك الزر الاستمارة عند الضغط عليه إلى الخاصية action الخاصة بالاستمارة.

نحفظ هذا في نفس المجلد كما فعلنا من قبل، لكن نستدعي hello.htm في هذه المرة، ونتحقق من صحة عملها بكتابة ما يلي في شريط العنوان:

http://localhost:8000/hello.htm

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

كتابة شيفرة CGI

يشبه برنامج CGI برامج بايثون التي كتبناها من قبل، باستثناء أمرين هما:

• برنامج CGI يستورد وحدة CGI.
• يوجد في مجلد باسم cgi-bin، في جذر خادم الويب، ويكون هذا البرنامج تنفيذيًا executable، لنحقق الأمر الثاني ننشئ مجلد cgi-bin داخل مجلد html، ثم ننشئ ملفًا داخل ذلك المجلد الجديد ونسميه sayhello.py يحتوي على الشيفرة التالية:

#!/usr/bin/env python3
import cgi

# استخرج حقول البيانات
data = cgi.FieldStorage()
username = data["username"].value 

# \n\n الإجبارية مع اللاحقة http أرسل ترويسة:
print("ContentType: text/html\n\n") 

# HTML والآن، أرسل محتوى
print("<!doctype html>\n<html><head>")
print("<title>Hello %s</title></head>" % username)
print('''
<body>
   <h1>Welcome %s</h1>
</body>
</html>''' % username)

تنفَّذ العمليات الخاصة بالبيانات داخل استدعاء FieldStorage، حيث تجمع وحدة cgi جميع البيانات من طلب http، وتضعها في قاموس لنستطيع الوصول إليها بسهولة باستخدام مفاتيح نصية هي خاصيات name من الاستمارة الخاصة بنا.

نلاحظ كيف تمكننا علامات الاقتباس الثلاثية الخاصة ببايثون من هيكلة الخرج في HTML بصورة يمكن قراءتها -انظر قسم head و body.

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

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

خاتمة

نأمل في نهاية هذا المقال أن تكون تعلمت ما يلي:

• تُنشأ الطلبات إلى خوادم الويب باستخدام طلبات http GET.
• يرد خادم الويب بمستند HTML.
• تُمرَّر البيانات في رابط الطلب أو متغيرات البيئة.
• تعالج وحدة CGI البروتوكول الأساسي.
• تُجلب بيانات الاستمارة من خلال قاموس FieldStorage.
• واجهة CGI مناسبة لاستمارات الويب البسيطة، مثل شاشات تسجيل الدخول، إلا أنها لا تناسب التطبيقات الكبيرة.

ترجمة -بتصرف- للفصل الثلاثين: Writing Web Applications من كتاب Learn To Program لصاحبه Alan Gauld.

اقرأ أيضًا

• المقال التالي: استخدام أطر العمل في برمجة تطبيقات الويب: فلاسك نموذجا
• المقال السابق: برمجة عملاء ويب باستخدام بايثون
• أساسيات بناء تطبيقات الويب في ريآكت
• كيف تكتب أول برنامج لك في بايثون 3
• البرمجة بلغة بايثون

سنغطي في هذا المقال من سلسلة تعلم البرمجة ما يلي:

• إرسال الطلبات إلى خادم الويب.
• إرسال البيانات إلى الخادم.
• معالجة HTML بواسطة html.parser.
• الخيارات الأخرى.

برمجة عملاء الويب

يمكن وصف برمجة عملاء الويب في تعريفين رئيسيين هما:

1. استخدام جافاسكربت لتعديل محتوى صفحة الويب داخل المتصفح، بتغيير ألوان العناصر وتحريك اللوحات حولها، وإظهار العناصر أو إخفائها، وجلب أجزاء من البيانات الأولية من الخادم، مثل حالة البحث الحي live search مثلًا. وهي ليست معقدةً، لكنها تتطلب معرفةً عميقةً بكل من HTML و CSS، ومن ثم فهي خارج نطاق شرحنا، فإذا أردت معرفة المزيد عن مثل هذا النوع من برمجة عملاء الويب فانظر سلسلة مدخل إلى html5 مثلًا في أكاديمية حسوب، وكتاب نحو فهم أعمق لتقنيات HTML5، كما توجد عدة مكتبات وأطر عمل لجافاسكربت يجب البحث فيها وتعلمها، لعل أشهرها jQuery، والتي يمكن القراءة عنها في توثيق jQuery في موسوعة حسوب، وغيرها من السلاسل والمواد العلمية في الأكاديمية والموسوعة.
2. إنشاء برنامج يعمل على حاسوب ويتصل بخادم ويب متظاهرًا بأنه برنامج متصفح ويب، حيث يجلب هذا البرنامج بعض البيانات للتحليل، وهو ما يسمى بالبوت bot -اختصار robot-، أو يتبع بعض الروابط من موقع لآخر بحثًا عن بيانات تتعلق بموضوع ما، وهو ما يسمى بعناكب الويب web spyders أو زاحفات الوب، وسندرس بعض هذه الأنواع من برامج عملاء الويب في هذا المقال.

التعلم بالتطبيق

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

مهمة هذا التدريب هي بناء برنامج يولد صفحة ويب جديدةً، تحتوي على تجميعة من جميع محتويات قائمة "سنغطي في هذا المقال (What will we cover?‎)" ونحتاج إلى تنفيذ بضعة أمور لبناء ذلك البرنامج:

1. قراءة محتوى HTML لملف الفهرس.
2. تحليل محتويات الصفحة، واستخراج جميع الروابط الموجودة في الجزء الأيسر إلى قائمة.
3. جلب محتوى HTML الخاص بكل رابط من روابط تلك القائمة.
4. استخراج قائمة النقاط الموجودة في قسم "What will we cover" إلى قائمة جديدة.
5. توليد صفحة HTML باستخدام البيانات التي جمعناها.

جلب المحتوى

رأينا سابقًا كيفية جلب صفحة HTML بسيطة من خادم باستخدام الوحدة urllib.request:

import urllib.request as url
site = url.urlopen('http://www.alan-g.me.uk/l2p2/index.htm')
page = site.read()

لدينا الآن سلسلة نصية تحتوي على شيفرة HTML الخاصة بالصفحة الرئيسية، أو صفحة المستوى الأعلى للنسخة الأجنبية من الفصول، وسنلاحظ صعوبة قراءة الخرج، لهذا نستخدم خيار عرض المصدر view source الموجود في المتصفح لننظر في شيفرة HTML، لنرى أن جدول المحتويات موجود في زوج من وسوم nav -اختصار للتنقل navigation- وأن كل قائمة من قوائم الفصول الموجودة في كل قسم تُجمع في قائمة غير مرتبة unordered list، تحمل الوسم ul، ونميز كل عنصر فيها بوجود وسم li فيه، وتمثل جميع عناصر القائمة روابط تشعبيةً إلى ملفات الفصول، لهذا نجدها محاطةً بوسم الرابط التشعبي <a>.

مهمتنا التالية استخراج جميع عناصر <a> داخل لوحة nav من الصفحة.

استخراج محتوى الوسوم

ذكرنا في المقدمة أننا نستطيع استخدام عمليات البحث النصية البسيطة للعثور على الوسوم وغيرها في صفحات الويب، لكن يفضل استخدام محلل HTML مناسب، لذا سنستخدم الصنف HTMLParser الموجود في وحدة المكتبة القياسية html.parser، وهو محلل لغوي مجرَّد abstract، مدفوع بالأحداث أو حدَثي event-driven، ويجب أن نقسمه إلى أصناف فرعية subclasses لتوفير المزايا التي نريدها، مع ملاحظة أنه يستدعي تابعين، الأول هو handle_starttag()‎ عند كل وسم HTML افتتاحي، والثاني هو handle_endtag()‎ عند كل وسم إغلاق، ويجب أن نوفر النسخ الخاصة بنا من تلك التوابع لتنفذ الإجراءات المناسبة عند العثور على الوسوم التي نريدها، ونريد في حالتنا هذه أن نجد كل الروابط الموجودة في لوحة nav، لذا يجب تعيين راية flag نسميها in_nav في كل مرة نعثر فيها على وسم nav، فإذا وجدنا وسم a وكانت الراية True فسنحفظ خاصية href في قائمة، حيث تُمرَّر الخاصيات إلى التابع في صف tuple من ثنائيات المفتاح/القيمة، ونريد أخيرًا التقاط وسم الإغلاق ‎/nav، وإعادة تعيين الراية إلى False، لضمان أننا لا نجمع أي روابط من خارج لوحة المحتويات، وعليه سنعِدّ المحلل اللغوي، ونتأكد من قدرته على تعرّف الوسوم الثلاثة المطلوبة باستخدام تعليمات الطباعة كما يلي:

import urllib.request as url
import html.parser

class LinkParser(html.parser.HTMLParser):
    def __init__(self):
        super().__init__()
        self.links = []  #list to store the links
        self.is_nav = False  # the flag

    def handle_starttag(self, name, attributes):
        if name == 'nav':
            print("We found a <nav> tag")
        elif name == 'a':
            print("We found an <a> tag")

    def handle_endtag(self, name):
        if name == 'nav':
            print("We found a </nav> tag")

site = url.urlopen('http://www.alan-g.me.uk/l2p2/index.htm')
page = site.read().decode('utf8') # convert bytes to str

parser = LinkParser()
parser.feed(page)

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

import urllib.request as url
import html.parser

class LinkParser(html.parser.HTMLParser):
    def __init__(self):
        super().__init__()
        self.links = []  # قائمة لتخزين الروابط
        self.is_nav = False  # الراية

    def handle_starttag(self, name, attributes):
        if name == 'nav':
            self.is_nav = True
        elif name == 'a' and self.is_nav:
            for key,val in attributes:
                if key == "href":
                    self.links.append(val)

    def handle_endtag(self, name):
        if name == 'nav':
            self.is_nav = False

site = url.urlopen('http://www.alan-g.me.uk/l2p2/index.htm')
page = site.read().decode('utf8') # حوِّل سلسلة البايت إلى سلسلة نصية

parser = LinkParser()
parser.feed(page)
print(parser.links)

نلاحظ هنا أن التغييرات التي أجريناها كانت في التابعين handle_starttag()‎ وhandle_endtag()‎، إضافةً إلى السطر الأخير في الشيفرة print(parser.links)‎، ويجب أن تصبح النتيجة كما يلي:

['tutintro.htm', 'tutneeds.htm', 'tutwhat.htm', 'tutstart.htm', 'tutseq1.htm', 
'tutdata.htm', 'tutseq2.htm', 'tutloops.htm', 'tutstyle.htm', 'tutinput.htm', 
'tutbranch.htm', 'tutfunc.htm', 'tutfiles.htm', 'tuttext.htm', 'tuterrors.htm', 
'tutname.htm', 'tutregex.htm', 'tutclass.htm', 'tutevent.htm', 'tutgui.htm', 
'tutrecur.htm', 'tutfctnl.htm', 'tutcase.htm', 'tutpractice.htm', 'tutdbms.htm', 
'tutos.htm', 'tutipc.htm', 'tutsocket.htm', 'tutweb.htm', 'tutwebc.htm', 
'tutwebcgi.htm', 'tutflask.htm', 'tutrefs.htm']

استخراج النقاط من الفصول

بعد أن حصلنا على قائمة الفصول نريد إنشاء دالة تستطيع استخراج النقاط التي في أول كل صفحة، لذا سنستخدم خاصية View Source الموجودة في المتصفح مرةً أخرى، إذ نفحص شيفرة HTML الخاصة بإطار الفصل، فنرى أننا ننظر في مجموعة من عناصر القائمة الموجودة داخل وسم div، مع تعيين الخاصية class على القيمة "todo"، وهذا يشبه تقريبًا ما فعلناه عند بحثنا عن الروابط، وسننشئ الآن دالةً تأخذ سلسلة HTML وتعيد قائمةً من سلاسل li، وسنضيف اسم الملف في الشيفرة ونثبته ليكون tutstart.htm.

import urllib.request as url
import html.parser

class BulletParser(html.parser.HTMLParser):
    def __init__(self):
        super().__init__()
        self.in_todo = False
        self.is_bullet = False
        self.bullets = []

    def handle_starttag(self, name, attributes):
        if name == 'div':
           for key, val in attributes:
               if key == 'class' and val == 'todo':
                   self.in_todo = True
        elif name == 'li':
            if self.in_todo:
               self.is_bullet = True

    def handle_data(self, data):
        if self.is_bullet:
            self.bullets.append(data)
            self.is_bullet = False  # أعد تعيين الراية

    def handle_endtag(self, name):
        if name == 'div':
            self.in_todo = False

topic_url = "http://www.alan-g.me.uk/l2p2/tutstart.htm"

def get_bullets(aTopic):
    site = url.urlopen(aTopic)
    topic = site.read().decode('utf8')
    topic_parser = BulletParser()
    topic_parser.feed(topic)
    return topic_parser.bullets

print( get_bullets(topic_url) )

لاحظ أن لدينا تابع معالجة حدث إضافي سنعيد تعريفه، وهو handle_data()‎، لأننا نريد استخراج البيانات الموجودة في وسوم <li> بدلًا من الوسم نفسه أو خصائصه، وفيما عدا ذلك تشابه هذه الشيفرة المثال السابق، حيث نعين الراية in_todo لتوضيح متى نكون داخل صندوق المحتويات، وكذلك الراية is_bullet التي تشير إلى أننا وجدنا عنصر قائمة داخل الصندوق، ثم نعيد تعيين راية is_bullet بمجرد قراءتنا للبيانات، ونعيد تعيين is_todo عندما نترك الصندوق، أي عند ‎</div>‎.

يمكن دمج البرنامجين معًا، بإضافة الصنف والدالة الجديدين إلى الملف السابق، ويتبقى أن نكتب حلقة for للتكرار على الروابط من المحلل الأول وإرسالها إلى دالة get_bullets()‎، ثم تُجمع النتائج في قاموس عام global dictionary مرتب وفق الفصول، كما سننظمها أكثر من خلال إنشاء دالة get_topics()‎ التي تشبه get_bullets()‎، يمكن أن نضيف شيئًا لمعالجة الأخطاء هنا، ونحوله إلى تنسيق وحدة في نفس الوقت، كما يلي:

import urllib
import urllib.request as url
import html.parser

###### Link handling code  ####

class LinkParser(html.parser.HTMLParser):
    def __init__(self):
        super().__init__()
        self.links = []  #list to store the links
        self.is_nav = False  # the flag

    def handle_starttag(self, name, attributes):
        if name == 'nav':
            self.is_nav = True
        elif name == 'a' and self.is_nav:
            for key,val in attributes:
                if key == "href":
                    self.links.append(val)

    def handle_endtag(self, name):
        if name == 'nav':
            self.is_nav = False

def get_topics(aSite):
    try:
        site = url.urlopen(aSite)
        page = site.read().decode('utf8') # convert bytestring to str
        link_parser = LinkParser()
        link_parser.feed(page)
        return link_parser.links
    except urllib.error.HTTPError:
        return []


##### Bullet handling code

class BulletParser(html.parser.HTMLParser):
    def __init__(self):
        super().__init__()
        self.in_todo = False
        self.is_bullet = False
        self.bullets = []

    def handle_starttag(self, name, attributes):
        if name == 'div':
           for key, val in attributes:
               if key == 'class' and val == 'todo':
                   self.in_todo = True
        elif name == 'li':
            if self.in_todo:
               self.is_bullet = True

    def handle_data(self, data):
        if self.is_bullet:
            self.bullets.append(data)
            self.is_bullet = False  # reset the flag

    def handle_endtag(self, name):
        if name == 'div':
            self.in_todo = False

def get_bullets(aTopic):
    try:
        site = url.urlopen(aTopic)
        topic = site.read().decode('utf8')
        topic_parser = BulletParser()
        topic_parser.feed(topic)
        return topic_parser.bullets
    except urllib.error.HTTPError:
        return []

#### driver code  ####
if __name__ == "__main__":
    summary = {}
    site_root = "http://www.alan-g.me.uk/l2p2/"

    the_topics = get_topics(site_root+'index.htm')

    for topic in the_topics:
        topic_url = site_root + topic
        summary[topic] = get_bullets(topic_url)

    print(summary['tutdata.htm'])

لا زال بإمكاننا إجراء المزيد من التنظيم والترتيب، من خلال أخذ اثنين من أصناف المحلل والدوال المرتبطة بهما إلى وحدات منفصلة، لكن نترك هذا تدريبًا لك، لذا أنشئ الوحدتين linkparser.py و bulletparser.py، واستوردهما إلى الشيفرة المتبقية التي تستطيع حفظها باسم topic_summary.py، ويجب أن يبدو الملف الأخير أشبه بما يلي:

import linkparser as LP
import bulletparser as BP

if __name__ == "__main__":
    summary = {}
    site_root = "http://www.alan-g.me.uk/l2p2/"

    the_topics = LP.get_topics(site_root+'index.htm')

    for topic in the_topics:
        topic_url = site_root + topic
        summary[topic] = BP.get_bullets(topic_url)

    print(summary['tutdata.htm'])

إنشاء صفحة الملخص

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

import linkparser as LP
import bulletparser as BP
import time

def create_summary(filename,data):
    with open(filename, 'w') as outf:
        # اكتب الترويسة
        outf.write('''<!Doctype htm>
<html><body>
<h1>Summary of tutor topics</h1>
<dl>''')

        # اكتب اسم كل فصل...
        for topic in data:
            outf.write('<dt>%s</dt>' % topic)
            # ...and its bullets
            for bullet in data[topic]:
                outf.write("<dd>%s</dd>" % bullet)

        # اكتب التذييل
        outf.write('''
</dl>
</body></html>''')

if __name__ == "__main__":
    summary = {}
    site_root = "http://www.alan-g.me.uk/l2p2/"
    summary_file = './topic_summary.htm'

    the_topics = LP.get_topics(site_root+'index.htm')

    for topic in the_topics:
        topic_url = site_root + topic
        summary[topic] = BP.get_bullets(topic_url)
        time.sleep(1) # DOS تعطيل رؤية الخادم له على أنه هجمة

    create_summary(summary_file, summary)
    print('OK')

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

إرسال البيانات في الطلب

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

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

إرسال سلسلة بحث إلى GitHub

تنقسم برمجة عملاء الويب web clients عمليًا إلى جزء علمي وفق قواعد معروفة مسبقًا ونتوقع نتائجها، وجزء يأتي بالتجربة والخطأ، ويمكن تعلم الكثير عن موقع ويب بزيارته من خلال متصفح ويب، وإلقاء نظرة متفحصة في كل من شريط العنوان ومصدر الصفحات، فإذا زرنا مستودع الشيفرات مفتوحة المصدر في GitHub مثلًا، وبحثنا عن كلمة "python" فسنرى أن عنوان الصفحة المعادة يكون أشبه بما يلي:

https://github.com/search?utf8=%E2%9C%93&q=python&type=

يشير الجزء utf8=%E2%9C%93 إلى محرف يونيكود -هو '- الذي يخبرنا أن البحث يستخدم UTF-8، ونستطيع تجاهل هذا التفصيل وكذلك type=‎ الفارغة في النهاية، ونرسل ما يلي:

http://github.com/search?q=python

وسنرى أنها تعطينا نفس النتيجة.

نستطيع اكتشاف نوع هيكل HTML المُعاد من خلال عرض مصدر الصفحة، وخصائص العنصر element properties باستخدام أدوات الفحص الخاصة بالمتصفح inspection tools، ونستطيع إجراء البحث النصي لشاشة مصدر الصفحة في حالة GitHub ونحصل منه على أول نتيجة -والتي كانت geekcomputers/Python عند بحثنا-، والتي بدت كما يلي:

<div class="repo-list-item d-flex flex-justify-start py-4 public source">
  <div class="col-8 pr-3">
    <h3>
      <a href="/geekcomputers/Python" class="v-align-middle">geekcomputers/<em>Python</em></a>
    </h3>
...

نرى هنا كيفية استخراج الروابط، وصعوبته أكثر مما في مثال topic_summary.htm السابق.

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

وتوجد عدة مشاكل أخرى لا يتسع لها شرحنا، لكن نشير إلى أهمها والتي ينبغي البحث فيها، مثل معالجة محاولات تسجيل الدخول، واستخدام ملفات تعريف الارتباط cookies، ومعالجة اتصالات https المشفرة، فيمكن تنفيذ كل ذلك بقليل من الجهد، غير أنها خارج سياق شرحنا كما ذكرنا، ويمكن استخراج أغلب المعلومات من صفحة HTML باستخدام المحلل بدمج تباديل مختلفة من تلك التقنيات، إلا أننا قد نحصل على شيفرة HTML غير متقنة الكتابة أو التنسيق، وعندها سنحتاج إلى كتابة شيفرة خاصة لتصحيح الشيفرة، بل قد نضطر إلى كتابتها إلى ملف نصي واستخدام متحقق HTML خارجي -مثل HTMLtidy- لتصحيحها، إذا كان التشوه الحاصل فيها أكثر مما يمكن تعديله يدويًا، وذلك قبل أن نحللها، أو يمكن استخدام حزمة من طرف ثالث -مثل Beautiful Soup- التي تستطيع التعامل مع أغلب المشاكل الشائعة في HTML.

اكتشاف رموز الخطأ

يعيد الخادم أحيانًا أخطاءً بدلًا من صفحات الويب التي نتوقعها، ويجب أن نتمكن من التقاط تلك الأخطاء وقراءتها، والتي يعرضها المتصفح في صورة خطأ "Page Not Found" المشهور، أو صورة عبارات ألطف قليلًا، لكن إذا كنا نحن الذين نجلب البيانات بأنفسنا من الخادم فسنجد أن الخطأ يأتي في صورة رمز خطأ في ترويسة http، التي يحولها urllib.request إلى استثناء urllib.error.HTTPError، وبما أننا نعرف كيفية التقاط الاستثناءات باستخدام بنية try/except العادية، فنستطيع التقاط تلك الأخطاء بسهولة كما يلي:

import urllib.request as url
import urllib.error
try:
   site = url.urlopen("http://some.nonexistent.address/foo.html")
except urllib.error.HTTPError, e:
   print e.code

تأتي القيمة الموجودة في urllib.error.HTTPError.code من أول سطر من رد HTTP الخاص بخادم الويب، مباشرةً قبل بداية الترويسات، مثل "HTTP/1.1 200 OK" أو "HTTP/1.1 404 Not Found"، ويتكون من رقم الخطأ، ويمكن الاطلاع على أشهر رموز الخطأ التي يعيدها خادم الويب في هذه الصفحة من موقع w3، وما يهمنا هي الأخطاء التي تبدأ بالرقم 4 أو 5، وأغلب تلك الأخطاء ستكون:

• 401: غير مصرح له Unauthorized.
• 404: الصفحة غير موجودة Page not found.
• 407: يُطلب توثيق الوكيل Proxy Authentication Required.
• 500: خطأ داخلي في الخادم Internal Server Error.
• 503: الخدمة غير متاحة Service Unavailable.
• 504: انتهت المهلة الزمنية للبوابة Gateway Timeout.

قد يكون المطلوب في بعض تلك الأخطاء مثل -503 و504- مجرد إعادة المحاولة بعد بضعة دقائق، أما في الخطأ 407 فقد نحتاج إلى مزيد من العمل للوصول إلى صفحة الويب، ولمزيد من التفاصيل حول هذه الرموز انظر مقال رموز الإجابة في HTTP.

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

خاتمة

في نهاية هذا المقال نأمل أن تكون تعلمت ما يلي:

• تُنشأ طلبات إلى خوادم الويب باستخدام طلبات http GET.
• يرد خادم الويب بمستند HTML.
• نحتاج إلى تحليل HTML لاستخراج البيانات المطلوبة.
• توفر بايثون عدة وحدات للتحليل، وأبسطها وحدة html.parser.
• توفر وحدات من طرف ثالث، مثل BeautifulSoup، وسائل تحليل أسهل وأفضل.

ترجمة -بتصرف- للفصل التاسع والعشرين: Web Client Programming من كتاب Learn To Program لصاحبه Alan Gauld.

اقرأ أيضًا

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

تحدثنا في هذه السلسلة عن عناصر الواجهة الرسومية Widgets ثم بدأنا بشرح أهم العناصر فيها وهي حاوية العنوان label وصناديق المدخلات Entry ثم انتقلنا إلى الأزرار Buttons ومربعات الرسائل messagebox ونستكمل سلسلتنا التعليمية في هذا المقال لواجهات المستخدم الرسومية بعنصرين مهمين في الواجهات لعرض خيارات مختلفة للمستخدم هما مربعات الاختيار Checkbutton و أزرار الانتقاء Radio Button، إذ سنستعرض طريقة إنشائها وخصائصها، ثم ننتقل بعد ذلك إلى الحديث عن القوائم Menus وخصائصها.

هذه المقالة جزء من سلسلة مقالات تشرح أساسيات مكتبة TKinter لبناء واجهات رسومية في بايثون، وإليك فهرس السلسلة كاملة:

• واجهات المستخدم الرسومية في بايثون باستخدام TKinter.
• مدخل إلى عناصر واجهات المستخدم الرسومية Widgets في بايثون.
• حاوية العنوان label وصناديق المدخلات Entry في واجهة المستخدم الرسومية في بايثون.
• الأزرار Buttons ومربعات الرسائل messagebox في واجهة المستخدم الرسومية في بايثون.
• مربعات الاختيار وأزرار الانتقاء والقوائم في واجهة المستخدم الرسومية في بايثون.

مربعات الاختيار Checkbutton

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

إنشاء مربعات الاختيار داخل النافذة

يتم اختيار اسم الكائن المطلوب ليمثل مربعات الاختيار ويستخدم الصنف Checkbutton من مكتبة Tkinter، ويعطى الصنف أولًا المكان الذي نريد وضع المربع فيه وهو النافذة الرئيسية، ومن ثم نص الخيار المراد عرضه أمام مربع الاختيار باستخدام الخاصية text على النحو التالي:

Button1 = Checkbutton(main_window, text = "الخيار الأول ")

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

Button1 = Checkbutton(main_window, text = "الخيار الأول ",
                    onvalue = "True",offvalue = "False") 

ونضيف عدة خصائص مع مربع الاختيار منها command ونربط بها الدالة التي نريد نداءها عند تغير حالة المربع من مُختار إلى غير مختار، ونستطيع الحصول على قيمة الاختيار عند ربط الخاصية variable بمتغير فإذا كانت القيمة رقمية يكون من نوع IntVar وإذا كانت غير ذلك من نوع StringVar، وتكون شفرة مربع الاختيار كاملة على النحو التالي:

Checkbutton1 = IntVar()
Button1 = Checkbutton(main_window, text = "الخيار الأول ",
                    onvalue =2 ,offvalue = 1,
                    variable = Checkbutton1 ,
                      command=get_choice)

حيث أن get_choice هي الدالة التي سيتم ندائها عند تغير الحالة، وفي النهاية نضيفها للدالة الرئيسية باستخدام الدالة pack.

خصائص مربعات الاختيار

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

Button1.select()
أو
Button1.deselect()

أزرار الانتقاء Radio Button

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

إنشاء أزرار الانتقاء داخل النافذة

يتم اختيار اسم الكائن المطلوب ليمثل مربعات الاختيار ويستخدم الصنف Radiobutton من مكتبة Tkinter، ويعطى الصنف أولًا المكان الذي نريد وضع المربع فيه وهو النافذة الرئيسية، ومن ثم نص الخيار المراد عرضه أمام زر الانتقاء باستخدام الخاصية text على النحو التالي:

Button1 = Radiobutton(main_window, text = "الخيار الأول ")

شفرة إنشاء الأزرار شبيهة جدًا بمربعات الاختيار، وتختلف عنها بأن خاصية variable يجب أن تحتوي على متغير واحد تشترك فيه جميع الخيارات قد يكون من نوع IntVar إذا كانت قيم الخيارات رقمية أو نوع StringVar إذا كانت غير ذلك، كذلك نستخدم الخاصية value لنعطي كل خيار قيمة مختلفة عن الآخر.

Button1 = Radiobutton(main_window, text = "الخيار الأول ",
                      variable = Var1, value = 1)

في هذا المثال يجب على جميع أزرار الانتقاء ان يكون لها نفس هذه القيمة variable = Var1، ونستخدم الخاصية command لنربطها بالدالة التي ستُسدعى في كل مرة يتم فيها تغيير الاختيار من بين خيارات أزرار الانتقاء المطروحة.

خصائص أزرار الانتقاء

نستطيع كما في كل عناصر واجهات المستخدم الرسومية أن نعدل خصائصها كتغيير لون النص ولون الخلفية ونوع الخط وشكل المؤشر بنفس الطريقة السابقة وبنفس الخصائص المستخدمة، وكما في مربعات الاختيار نستطيع استخدام الدالة select والدالة deselect مع كل عنصر، سنعرض في المثال التالي للمستخدم مجموعة أزرار انتقاء ليختار منها واحدا وتعرض حاوية عنوان اسم الخيار الذي اختاره المستخدم:

from tkinter import *

main_window = Tk()
main_window.title("أزرار الانتقاء ")

Var1 = StringVar()
def sel():
   selection = "لقد قمت باختيار  " + str(Var1.get())
   label.config(text = selection)

B1=Radiobutton(main_window, text = "الخيار الأول ",variable = Var1, value = "الأول", command=sel)
B2=Radiobutton(main_window, text = "الخيار الثاني ",variable = Var1, value = "الثاني", command=sel)
B3=Radiobutton(main_window, text = "الخيار الثالث ",variable = Var1, value = "الثالث", command=sel)

B1.pack()
B2.pack()
B3.pack()

label = Label(main_window)

label.pack()

main_window.mainloop()

نحصل على النتيجة التالية:

أزرار الانتقاء

القوائم Menus

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

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

إنشاء القائمة داخل النافذة

يتطلب إنشاء القائمة عدة خطوات:

الخطوة الأولى،إنشاء كائن ليمثل القائمة الرئيسية ويستخدم المصنف Menu من مكتبة Tkinter، ويعطى الصنف المكان الذي نريد وضع الإطار فيه وهو النافذة الرئيسية على النحو التالي:

main_menu=Menu(main_window)

الخطوة الثانية، نحتاج إلى ربط القائمة الرئيسية main_menu بالنافذة الرئيسية main_window باستخدام الخاصية menu وبما أننا نقوم بتعديل خصائص النافذة بعد عملية إنشائها، فسنحتاج إلى استخدام الدالة config على النحو التالي:

main_window.config(menu=main_menu)

الخطوة الثالثة، نحتاج إلى إضافة القوائم الفرعية التي ستنسدل من القائمة الرئيسية مثل قائمة ملف، تعديل، المظهر والخيارات ونحوها، ونحتاج لفعل ذلك إلى إنشاء كائن من الصنف Menu ويعطى المكان الذي نريد وضعه فيه وهو القائمة الرئيسية:

file_menu = Menu(main_menu)

بعد ذلك نقوم بربطه مع القائمة الرئيسية باستخدام الدالة add_cascade وتعطى رقعة التعريف label التي يكتب عنوان هذه القائمة فيه، واسم القائمة file_menu:

 main_menu.add_cascade(
    label="ملف",
    menu=file_menu)  

ستكون الشفرة كاملة على النحو التالي:

from tkinter import *

main_window = Tk()
main_window.title(" القوائم ") 

main_menu=Menu(main_window)
main_window.config(menu=main_menu)
file_menu = Menu(main_menu)

main_menu.add_cascade(
    label="ملف",
    menu=file_menu
)
main_window.mainloop()