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

كيف تعمل فلاتر الصور؟

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

كما نعرف فإن الصورة مكوّنة من عدد من البكسلات pixels التي تحتوي على ثلاث قيم من 0 إلى 255 لكل من القنوات اللونية الثلاث وهي الأحمر والأخضر والأزرق التي يرمز لهم بالمصطلح RGB. وبالتالي، يمكننا تمثيل الصورة بمصفوفة عددية كما يوضّح الشكل التالي:

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

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

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

بعد أن تعرفنا على آلية عمل الفلاتر على الصورة دعونا نبدأ خطوات تطوير تطبيقنا بايثون يمكننا من رفع الصورة المطلوبة وتعديلها بفلاتر مختلفة.

الخطوة الأولى: تجهيز بيئة العمل

لنبدأ أولًا بتجهيز بيئة العمل عن طريق تجهيز المكتبات التي سنستخدمها، بالإضافة لهيكل المشروع من ملفات ومجلدات. سننشئ مجلدًا نسميه image-filters وهو المجلد الذي سيمثل المجلد الجذر لمشروعنا، ومن ثم ننشئ بداخله مجلدين الأول باسم images الذي سنضع فيه الصور التي نريد فلترتها والثاني باسم output وهو المجلد الذي سنخزن فيه الصور الناتجة عن تطبيق الفلتر، وأخيرًا ننشئ ملف image_filters.py الذي سيحتوي الشيفرة البرمجية لبرنامجنا، ويمكننا إنشاء ملف يدعى README.md يشرح كيفية عمل البرنامج ومزاياه.

يصبح لدينا هيكل المشروع في النهاية كما يلي:

image-filters/
├── images/               # مجلد يحتوي الصور التي تريد فلترتها
│   ├── sample.jpg
├── output/               # مجلد نخزن فيه الصور الناتجة عن تطبيق الفلتر
├── image_filters.py      # الشيفرة البرمجية
├── README.md             # للتوثيق ‪(اختياري)‪‬‬

بعدها، نذهب إلى طرفية سطر الأوامر command line وننفّذ التعليمة التالية:

pip install opencv-python numpy pillow

ستتكفل هذه التعليمة بتحميل المكتبات التي سنستعين بها لتطبيق الفلاتر على الصور، وهي مكتبة opencv ومكتبة numpy ومكتبة pillow لذا يجب التأكد من توفر اتصال الإنترنت قبل تنفيذ الأمر.

يمكننا التأكد من أن عملية التحميل قد تمت بنجاح بتنفيذ السطر التالي:

py -c "import cv2; import numpy; import PIL; print('Packages installed successfully!')"

إن تمت العملية بنجاح سنحصل على رسالة Packages installed successfully!‎ في الطرفية.

الخطوة الثالثة: كتابة الهيكل الأساسي للبرنامج

نبدأ باستيراد import المكاتب التي سنستخدمها في بداية الشيفرة البرمجية داخل ملف image_filters.py سنستخدم أيضًا مكتبة os المضمنة في بايثون التي ستساعدنا على إنشاء المجلدات/المسارات:

import cv2
import numpy as np
import os

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

import tkinter as tk
from tkinter import filedialog, Label, Button, ttk
from PIL import Image, ImageTk

نحفظ كل من مسار الصورة مع اسمها واسم الفلتر الذي نختاره وسنبني الفلاتر المتاحة في برنامجنا في الخطوات التالية، ومن ثم نخزّن الصورة في متغير بالاستعانة بمكتبة opencv:

image = cv2.imread(image_path)

ننشئ filters نضمّن فيها جميع الفلاتر التي يدعمها برنامجنا بالشكل التالي:

filters = {
    "Grayscale": apply_grayscale,
    "Blur": apply_blur,
    "Edge Detection": apply_edges,
    "Sharpen": apply_sharpen,
    "Cartoon": apply_cartoon,
    "Remove Background": remove_background
}

إن أردنا تجزئة منطق البرنامج المطلوب ليسهل علينا فهمه، يمكننا النظر إليه بكونه يقدّم ثلاث مزايا أساسية:

1. تطبيق الفلتر على صورة
2. عرض الصورة على الواجهة البرمجية
3. حفظ الصورة التي طُبّق عليها الفلتر على الحاسب

لنشرح الشيفرة البرمجية لكل ميزة على حدى بالتفصيل فيما يلي.

تطبيق الفلتر على الصورة

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

def apply_filter():
# جعل نطاق المتغيرات نطاق عام يمكن الوصول إليهما في أي مكان من البرنامج
    global img, img_display

# بحال لم يختر المستخدم الصورة بعد أو لم يستطع البرنامج قراءة الصورة
    if img is None:
        return

# تخزين الفلتر الذي اختاره المستخدم من الواجهة الرسومية
    selected_filter = filter_var.get()

# في حال لم يكن الفلتر مدعومًا من قبل البرنامج
    if selected_filter not in filters:
        return

# نسخ الصورة بعد قرائتها وتطبيق الفلتر على الصورة
    image = img.copy()
    image = filters[selected_filter](image)

# تحويل الصورة إلى صورة بألوان RGB في حال كانت صورة بتدرجات رمادية
    if len(image.shape) == 2:  # Convert grayscale to RGB for display
        image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)

# ‫تحويل ترميز الصورة من نظام BGR إلى RGB‬
    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# تحويل مصفوفة القيم إلى صورة
    image = Image.fromarray(image)

# تحويل الصورة إلى ترميز يدعمه‫ Tkinter لعرضها على الواجهة الرسومية‬
    img_display = ImageTk.PhotoImage(image)

# عرض الصورة على الواجهة الرسومية
    label_img.config(image=img_display)

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

عرض الصورة على الواجهة الرسومية

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

def load_image():
    global img, img_display

# فتح نافذة مستعرض الملفات واختيار الصورة بالامتدادت المدعومة المضمنة
    file_path = filedialog.askopenfilename(filetypes=[("Image Files", "*.jpg;*.png;*.jpeg")])

# في حال تعذّر وجود الصورة
    if not file_path:
        return

# قراء الصورة وضبط أبعادها وتحضيرها للعرض على الواجهة الرسومية
    img = cv2.imread(file_path)
    img_resized = cv2.resize(img, (400, 300))
    img_resized = cv2.cvtColor(img_resized, cv2.COLOR_BGR2RGB)
    img_resized = Image.fromarray(img_resized)

# عرض الصورة على الواجهة
    img_display = ImageTk.PhotoImage(img_resized)
    label_img.config(image=img_display)

حفظ الصورة الناتجة على الحاسب

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

def save_image():
    global img

# في حال تعذر قراءة الصورة أو كونها فارغة
    if img is None:
        return

# الحصول على اسم الفلتر الذي اخترناه لتضمين اسمه في الصورة المحفوظة
    selected_filter = filter_var.get()
    output_dir = "output"

# ‫ننشئ مجلد الصور الناتجة output في حال عدم وجوده‬
    if not os.path.exists(output_dir):
        os.makedirs(output_dir)

    output_filename = os.path.join(output_dir, f"filtered_{selected_filter}.jpg")
    cv2.imwrite(output_filename, img)

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

الخطوة الخامسة: برمجة الواجهة الرسومية

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

نكتب الشيفرة البرمجية التالية لتحقيق الشكل السابق:

# إنشاء عقدة جذر البرنامج
root = tk.Tk()

# ضبط عنوان نافذة البرنامج وأبعادها
root.title("Image Filter App")
root.geometry("500x550")

# ‫إنشاء متغير img وإسناد قيمة أولية له‬
img = None

# إنشاء زر إضافة الصورة ونص العنوان
Label(root, text="Image Filter Application", font=("Arial", 16)).pack(pady=10)

Button(root, text="Load Image", command=load_image).pack(pady=5)

label_img = Label(root)
label_img.pack(pady=5)

# القائمة المنسدلة التي تحتوي على الفلاتر
filter_var = tk.StringVar()
filter_var.set("Grayscale") # نضبط فلتر التدرج الرمادي كقيمة افتراضية
filter_menu = ttk.Combobox(root, textvariable=filter_var, values=list(filters.keys()), state="readonly")
filter_menu.pack(pady=5)

# إضافة الأزرار
Button(root, text="Apply Filter", command=apply_filter).pack(pady=5)
Button(root, text="Save Image", command=save_image).pack(pady=5)

root.mainloop()

الخطوة الرابعة: كتابة الفلاتر المتاحة

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

فلتر التدرج الرمادي Grayscale

نبدأ بأبسط الفلاتر عملًا وهو فلتر تغيير ألوان الصورة إلى تدرجات اللون الرمادي:

def apply_grayscale(image):
    return cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

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

فلتر التغبيش Blur

ننتقل فيما بعد إلى فلتر التغبيش blur ولدى مكتبة opencv دالة جاهزة يمكننا استخدامها ألا وهي GaussianBlur ونمرر لها ثلاث قيم، الصورة ومقدار التشويش والانحراف المعياري للمرشح:

def apply_blur(image, ksize = (15,15)):
    return cv2.GaussianBlur(image, ksize, 0)

يمكننا زيادة مقدار التغبيش بزيادة قيمة المعامل الثاني ksize.

فلتر الكشف عن الحواف Edge detection

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

def apply_edges(image, low_threshold=100, high_threshold=200):
    return cv2.Canny(image, low_threshold, high_threshold)

يمكنك تغيير قيم العتبة الدنيا والعليا للتحكم بالحساسية، وسيولد لك البرنامج نتائجًا مختلفة.

فلتر الشحذ Sharpen

ننتقل إلى فلتر الشحذ Sharpen الذي يبرز حواف الصورة بشكل أكبر ويزيد من التباين في الصورة، نستخدم في هذا الفلتر مصفوفة معرّفة وهو أحد المرشحات Kernel التي ذكرناها في بداية المقال بالشكل التالي:

def apply_sharpen(image):
    kernel = np.array([[0, -1, 0],
                       [-1, 5, -1],
                       [0, -1, 0]])
    return cv2.filter2D(image, -1, kernel)

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

فلتر الرسم الكرتوني Cartoon

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

def apply_cartoon(image):
    # تحويل الصورة إلى صورة ذات تدرج رمادي ‪(بشكل مشابه للفلتر الأول)‎‬
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

    # تطبيق تغبيش على الصورة
    blurred = cv2.medianBlur(gray, 5)

    # التعرف على الحواف وتنعيمها للحصول على نتيجة تشبه صورة مرسومة
    edges = cv2.adaptiveThreshold(blurred, 255, cv2.ADAPTIVE_THRESH_MEAN_C,
                                  cv2.THRESH_BINARY, 9, 10)

    # تغبيش الصورة مع المحافظة على الحواف مشحوذة
    color = cv2.bilateralFilter(image, 9, 250, 250)

    # دمج صورة الحواف مع صورة الألوان
    cartoon = cv2.bitwise_and(color, color, mask=edges)

    return cartoon

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

فلتر إزالة الخلفية Remove Background

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

def remove_background(image):
    # ننشئ نسخة بذات أبعاد الصورة لكن نملؤها بالأصفار
    mask = np.zeros(image.shape[:2], np.uint8)

    # نستخدم خوارزمية‫ GrabCut الموجودة في opencv لإنشاء نموذج للكائن في الصورة‬
    bgd_model = np.zeros((1, 65), np.float64)
    fgd_model = np.zeros((1, 65), np.float64)

    # نعرف مستطيلًا حول النموذج الذي أنشأناه
    rect = (50, 50, image.shape[1] - 50, image.shape[0] - 50)

    # ‫ننفذ خوارزمية GrabCut ‬
    cv2.grabCut(image, mask, rect, bgd_model, fgd_model, 5, cv2.GC_INIT_WITH_RECT)
    mask = np.where((mask == 2) | (mask == 0), 0, 1).astype("uint8")

    # نطبق الصورة ذات القيم الصفرية على صورتنا لإزالة الخلفية
    result = image * mask[:, :, np.newaxis]

    return result

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

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

الشيفرة البرمجية الكاملة للتطبيق

إليكم كامل الشيفرة الخاصة بالتطبيق لاختبارها وتجربتها لديكم:

import cv2
import numpy as np
import os
import tkinter as tk
from tkinter import filedialog, Label, Button, ttk
from PIL import Image, ImageTk

# دالة فلتر التدرج الرمادي
def apply_grayscale(image):
    return cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# دالة فلتر التغبيش
def apply_blur(image, ksize=(25, 25)):
    return cv2.GaussianBlur(image, ksize, 0)

# دالة الكشف عن الحواف
def apply_edges(image, low_threshold=100, high_threshold=200):
    return cv2.Canny(image, low_threshold, high_threshold)

# دالة فلتر الشحذ
def apply_sharpen(image):
    kernel = np.array([[0, -1, 0],
                       [-1, 5, -1],
                       [0, -1, 0]])
    return cv2.filter2D(image, -1, kernel)

# دالة فلتر الرسوم الكرتونية
def apply_cartoon(image):
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    blurred = cv2.medianBlur(gray, 5)
    edges = cv2.adaptiveThreshold(blurred, 255, cv2.ADAPTIVE_THRESH_MEAN_C,
                                  cv2.THRESH_BINARY, 9, 10)
    color = cv2.bilateralFilter(image, 9, 250, 250)
    cartoon = cv2.bitwise_and(color, color, mask=edges)
    return cartoon

# ‫دالة فلتر إزالة الخلفية باستخدام خوارزمية Grab cut‬
def remove_background(image):
    mask = np.zeros(image.shape[:2], np.uint8)
    bgd_model = np.zeros((1, 65), np.float64)
    fgd_model = np.zeros((1, 65), np.float64)

    rect = (50, 50, image.shape[1] - 50, image.shape[0] - 50)
    cv2.grabCut(image, mask, rect, bgd_model, fgd_model, 5, cv2.GC_INIT_WITH_RECT)
    mask2 = np.where((mask == 2) | (mask == 0), 0, 1).astype("uint8")
    return image * mask2[:, :, np.newaxis]

# الفلاتر التي يدعمها البرنامج
filters = {
    "grayscale": apply_grayscale,
    "blur": apply_blur,
    "edges": apply_edges,
    "sharpen": apply_sharpen,
    "cartoon": apply_cartoon,
    "remove_bg": remove_background
}

def apply_filter():
# جعل نطاق المتغيرات نطاق عام يمكن الوصول إليهما في أي مكان من البرنامج
    global img, img_display

# بحال لم يختر المستخدم الصورة بعد أو لم يستطع البرنامج قراءة الصورة
    if img is None:
        return

# تخزين الفلتر الذي اختاره المستخدم من الواجهة الرسومية
    selected_filter = filter_var.get()

# في حال لم يكن الفلتر مدعومًا من قبل البرنامج
    if selected_filter not in filters:
        return

# نسخ الصورة بعد قرائتها وتطبيق الفلتر على الصورة
    image = img.copy()
    image = filters[selected_filter](image)

# تحويل الصورة إلى صورة بألوان RGB في حال كانت صورة بتدرجات رمادية
    if len(image.shape) == 2:  # Convert grayscale to RGB for display
        image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)

# ‫تحويل ترميز الصورة من نظام BGR إلى RGB‬
    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# تحويل مصفوفة القيم إلى صورة
    image = Image.fromarray(image)

# تحويل الصورة إلى ترميز يدعمه‫ Tkinter لعرضها على الواجهة الرسومية‬
    img_display = ImageTk.PhotoImage(image)

# عرض الصورة على الواجهة الرسومية
    label_img.config(image=img_display)

def load_image():
    global img, img_display

# فتح نافذة مستعرض الملفات واختيار الصورة بالامتدادت المدعومة المضمنة
    file_path = filedialog.askopenfilename(filetypes=[("Image Files", "*.jpg;*.png;*.jpeg")])

# في حال تعذّر وجود الصورة
    if not file_path:
        return

# قراء الصورة وضبط أبعادها وتحضيرها للعرض على الواجهة الرسومية
    img = cv2.imread(file_path)
    img_resized = cv2.resize(img, (400, 300))
    img_resized = cv2.cvtColor(img_resized, cv2.COLOR_BGR2RGB)
    img_resized = Image.fromarray(img_resized)

# عرض الصورة على الواجهة
    img_display = ImageTk.PhotoImage(img_resized)
    label_img.config(image=img_display)

def save_image():
    global img

# في حال تعذر قراءة الصورة أو كونها فارغة
    if img is None:
        return

# الحصول على اسم الفلتر الذي اخترناه لتضمين اسمه في الصورة المحفوظة
    selected_filter = filter_var.get()
    output_dir = "output"

# ‫ننشئ مجلد الصور الناتجة output في حال عدم وجوده‬
    if not os.path.exists(output_dir):
        os.makedirs(output_dir)

    output_filename = os.path.join(output_dir, f"filtered_{selected_filter}.jpg")
    cv2.imwrite(output_filename, img)

# إنشاء عقدة جذر البرنامج
root = tk.Tk()

# ضبط عنوان نافذة البرنامج وأبعادها
root.title("Image Filter App")
root.geometry("500x550")

# ‫إنشاء متغير img وإسناد قيمة أولية له‬
img = None

# إنشاء زر إضافة الصورة ونص العنوان
Label(root, text="Image Filter Application", font=("Arial", 16)).pack(pady=10)

Button(root, text="Load Image", command=load_image).pack(pady=5)

label_img = Label(root)
label_img.pack(pady=5)

# القائمة المنسدلة التي تحتوي على الفلاتر
filter_var = tk.StringVar()
filter_var.set("Grayscale") # نضبط فلتر التدرج الرمادي كقيمة افتراضية
filter_menu = ttk.Combobox(root, textvariable=filter_var, values=list(filters.keys()), state="readonly")
filter_menu.pack(pady=5)

# إضافة الأزرار
Button(root, text="Apply Filter", command=apply_filter).pack(pady=5)
Button(root, text="Save Image", command=save_image).pack(pady=5)

root.mainloop()

الخاتمة

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

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

يمكن تقدير مدى بطء هذه العملية بحساب بسيط حيث يمكن ترتيب عدد n من العناصر في أزواج بعدد من الطرق يساوي n(n-1)، وإذا حذفنا الأزواج المكررة -إذا اعتبرنا أن الزوج A-B هو نفسه B-A يكون لدينا عدد من الأزواج الفريدة يساوي n(n-1)/2 أو (n²-n)/2 للتبسيط، وكلما زادت قيمة n تناسبت تقريبيًا مع n2، وهنا قد يقال أن تعقيد الوقت Time complexity لخوارزميتنا هو O(n²). بعبارة أبسط، حين يتضاعف عدد الملفات يزيد زمن التشغيل أربع مرات تقريبًا، أي أن الوقت المستغرق لكل ملف يزيد مع زيادة العدد الإجمالي للملفات.

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

الأسلوب التقليدي

سنبدأ بتنفيذ الأسلوب غير الفعال الذي يعتمد على تعقيد الوقت O(N²) لكي نقارنه بالتصميمات المتطورة التي سنكتبها لاحقًا.

يأخذ البرنامج القصير أدناه -لنسميه brute_force_1.py- قائمة بأسماء الملفات من سطر الأوامر ثم يبحث عن الملفات المكررة، ويطبع النتائج المتطابقة:

import sys


# [bytes]
def same_bytes(left_name, right_name):
 left_bytes = open(left_name, "rb").read()
 right_bytes = open(right_name, "rb").read()
 return left_bytes == right_bytes
# [/bytes]


# [main]
def find_duplicates(filenames):
 matches = []
 for left in filenames:
 for right in filenames:
 if same_bytes(left, right):
 matches.append((left, right))
 return matches


if __name__ == "__main__":
 duplicates = find_duplicates(sys.argv[1:])
 for (left, right) in duplicates:
        print(left, right)
# [/main]

يستخدم هذا البرنامج دالة same_bytes تقرأ ملفين وتقارن بينهما "بايت مقابل بايت":

def same_bytes(left_name, right_name):
    left_bytes = open(left_name, "rb").read()
    right_bytes = open(right_name, "rb").read()
    return left_bytes == right_bytes

لاحظ في المثال أعلاه أننا نفتح الملفات في الوضع الثنائي binary mode باستخدام الوسم rb بدلًا من r المعتاد، وهذا يخبر لغة بايثون أن تقرأ البايتات تمامًا كما هي بدلًا من محاولة تحويلها إلى محارف نصية.

ننشئ مجلدًا باسم tests من أجل اختبار هذا البرنامج والبرامج الأخرى، ويحتوي على ستة ملفات:

نتوقع أن يتم الإبلاغ عن ملفات a الثلاثية وملفات b الثنائية كملفات مكررة:

python brute_force_1.py tests/*.txt

ينبغي أن نحصل على الخرج التالي:

tests/a1.txt tests/a1.txt
tests/a1.txt tests/a2.txt
tests/a1.txt tests/a3.txt
tests/a2.txt tests/a1.txt
tests/a2.txt tests/a2.txt
tests/a2.txt tests/a3.txt
tests/a3.txt tests/a1.txt
tests/a3.txt tests/a2.txt
tests/a3.txt tests/a3.txt
tests/b1.txt tests/b1.txt
tests/b1.txt tests/b2.txt
tests/b2.txt tests/b1.txt
tests/b2.txt tests/b2.txt
tests/c1.txt tests/c1.txt

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

import sys


def same_bytes(left_name, right_name):
    left_bytes = open(left_name, "rb").read()
    right_bytes = open(right_name, "rb").read()
    return left_bytes == right_bytes


# [dup]
def find_duplicates(filenames):
    matches = []
    for i_left in range(len(filenames)):
        left = filenames[i_left]
        for i_right in range(i_left):
            right = filenames[i_right]
            if same_bytes(left, right):
                matches.append((left, right))
    return matches
# [/dup]


if __name__ == "__main__":
    duplicates = find_duplicates(sys.argv[1:])
    for (left, right) in duplicates:
        print(left, right)

تحديد نطاق الحلقة الداخلية لإنتاج تركبيات فريدة.

تجزئة الملفات

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

إذا قُسمت الملفات إلى عدد g من المجموعات فستحتوي كل مجموعة على عدد N/g من الملفات، ويصبح إجمالي العمل المطلوب O(g(N / g²)) - على سبيل المثال: عدد g مجموعة * عدد مقارنات يساوي (N/g²) داخل كل مجموعة-، أي أننا نحصل على (N²/g) مما يعني أن زمن التشغيل الكلي ينخفض بزيادة عدد المجموعات.

تجميع الملفات عبر شيفرة التجزئة يقلص عدد المقارنات من 15 إلى 4 فقط.

نستطيع إنشاء معرفات للملفات باستخدام دالة تجزئة hash function لإنتاج شيفرة تجزئة hash code، وبما أن البايتات في الأصل عبارة عن أرقام فنستطيع إنشاء دالة تجزئة بسيطة عبر جمع قيم البايتات الموجودة في الملف ثم أخذ باقي القسم على رقم معين:

# [hash]
def naive_hash(data):
    return sum(data) % 13
# [/hash]

if __name__ == "__main__":
    # [example]
    example = bytes("hashing", "utf-8")
    for i in range(1, len(example) + 1):
        substring = example[:i]
        hash = naive_hash(substring)
        print(f"{hash:2} {substring}")
    # [/example]

إليك اختبارًا سريعًا يحسب شيفرة التجزئة لأجزاء من كلمة hashing يتزايد طولها:

example = bytes("hashing", "utf-8")
for i in range(1, len(example) + 1):
    substring = example[:i]
    hash = naive_hash(substring)
    print(f"{hash:2} {substring}")

يكون الخرج ما يلي:

0 b'h'
 6 b'ha'
 4 b'has'
 4 b'hash'
 5 b'hashi'
11 b'hashin'
10 b'hashing'

يبدو الخرج عشوائيًا، نريد إجراء اختبار أكثر صرامة عبر تجربة تجزئة كل سطر نصي في رواية دراكولا -نسخة مشروع جوتنبرج-، ثم نرسم مخططًا بيانيًا للتوزيع:

توزيع شيفرات التجزئة لكل سطر في رواية دراكولا.

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

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

توزيع شيفرات التجزئة للأسطر الفريدة في رواية دراكولا.

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

import sys
from naive_hash import naive_hash


def same_bytes(left_name, right_name):
    left_bytes = open(left_name, "rb").read()
    right_bytes = open(right_name, "rb").read()
    return left_bytes == right_bytes


def find_duplicates(filenames):
    matches = []
    for i_left in range(len(filenames)):
        left = filenames[i_left]
        for i_right in range(i_left):
            right = filenames[i_right]
            if same_bytes(left, right):
                matches.append((left, right))
    return matches


# [group]
def find_groups(filenames):
    groups = {}
    for fn in filenames:
        data = open(fn, "rb").read()
        hash_code = naive_hash(data)
        if hash_code not in groups:
            groups[hash_code] = set()
        groups[hash_code].add(fn)
    return groups
# [/group]


if __name__ == "__main__":
    # [main]
    groups = find_groups(sys.argv[1:])
    for filenames in groups.values():
        duplicates = find_duplicates(list(filenames))
        for (left, right) in duplicates:
            print(left, right)
    # [/main]

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

def find_groups(filenames):
    groups = {}
    for fn in filenames:
        data = open(fn, "rb").read()
        hash_code = naive_hash(data)
        if hash_code not in groups:
            groups[hash_code] = set()
        groups[hash_code].add(fn)
    return groups

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

groups = find_groups(sys.argv[1:])
for filenames in groups.values():
    duplicates = find_duplicates(list(filenames))
    for (left, right) in duplicates:
        print(left, right)

فيكون الخرج كما يلي:

tests/a2.txt tests/a1.txt
tests/a3.txt tests/a1.txt
tests/a3.txt tests/a2.txt
tests/b1.txt tests/b2.txt

تجزئة أفضل

بالعودة إلى صيغة O(n²/g) التي تخبرنا بمقدار الجهد المطلوب إذا قسمنا n من الملفات على g من المجموعات، فإذا كان لدينا عدد مجموعات يساوي عدد الملفات تمامًا -أي حين تكون n مساوية لـ g- فإن الجهد المطلوب لمعالجة n ملف سيكون O(n²/n) أو O(N) للتبسيط، وهذا يعني أن الجهد المطلوب سيتناسب طرديًا مع عدد الملفات، وبما أننا نحتاج إلى قراءة كل ملف مرة واحدة على الأقل على أي حال فلن نتمكن من تحقيق نتيجة أفضل من هذه، لكن كيف نضمن أن كل ملف فريد سيكون في مجموعته التي ينتمي لها؟

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

تصعب كتابة دوال التجزئة بالتشفير كما يصعب كذلك إثبات أن خوارزمية ما لديها الخصائص التي نريدها، لذا سنستخدم دالة من مكتبة التجزئة hashlib في لغة بايثون التي تنفذ خوارزمية التجزئة SHA-256.

تنتج هذه الدالة تجزئة بحجم 256 بت عند إعطائها بعض البايتات كمدخلات، وتُكتب عادة كسلسلة نصية من 64 محرف بالنظام الست عشري حيث يستخدم هذا النظام الأحرف A حتى F لتمثيل الأرقام من 10 إلى 15، فتحسب القيمة 3D5 مثلًا كالتالي:

3 × 16² + 13 × 16¹ + 5 × 16⁰ = 981 بالنظام العشري.

from hashlib import sha256

if __name__ == "__main__":
    # [example]
    example = bytes("hash", "utf-8")
    for i in range(1, len(example) + 1):
        substring = example[:i]
        hash = sha256(substring).hexdigest()
        print(f"{substring}\n{hash}")
    # [/example]

ويكون خرجها كما يلي:

b'h'
aaa9402664f1a41f40ebbc52c9993eb66aeb366602958fdfaa283b71e64db123
b'ha'
8693873cd8f8a2d9c7c596477180f851e525f4eaf55a4f637b445cb442a5e340
b'has'
9150c74c5f92d51a92857f4b9678105ba5a676d308339a353b20bd38cd669ce7
b'hash'
d04b98f48e8f8bcc15c6ae5ac050801cd6dcfd428fb5f9e65c4e16e7807340fa

مسألة عيد الميلاد

يمثل احتمال تشارك شخصين في نفس عيد الميلاد 1/365 مع تجاهل يوم 29 فبراير، ومن ثم تكون احتمالية ألا يتشاركاه هو 364/365، وإذا أضفنا شخصًا ثالثًا يكون احتمال ألا يتشارك عيد الميلاد مع الشخصين السابقين هي 363/365، وهكذا يكون الاحتمال الإجمالي لعدم تشارك هؤلاء الأشخاص في نفس عيد الميلاد هي (364/365)*(363/365)، وإذا استمر الحال على هذا النمط سنجد أن هناك احتمالًا بنسبة 50% لوجود شخصين يتشاركان يوم الميلاد نفسه في مجموعة مكونة من 23 شخصًا فقط، تزيد هذه النسبة إلى 99.9% مع وجود 70 شخصًا.

تطبيق المنطق على الملفات

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

$4 \times 10^{38}$

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

import sys
from hashlib import sha256

def find_groups(filenames):
    groups = {}
    for fn in filenames:
        data = open(fn, "rb").read()
        hash_code = sha256(data).hexdigest()
        if hash_code not in groups:
            groups[hash_code] = set()
        groups[hash_code].add(fn)
    return groups


if __name__ == "__main__":
    groups = find_groups(sys.argv[1:])
    for filenames in groups.values():
        print(", ".join(sorted(filenames)))

وعند تشغيل البرنامج:

python dup.py tests/*.txt

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

tests/a1.txt, tests/a2.txt, tests/a3.txt
tests/b1.txt, tests/b2.txt
tests/c1.txt

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

خاتمة

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

خريطة تصور اكتشاف الملفات المكررة باستخدام التجزئة.

• توضح هذه الخريطة كيف ننتقل من المقارنة الثنائية البطيئة O(n²) إلى التوزيع الذكي باستخدام التجزئة.
• تحول دالة التجزئة محتوى الملف إلى بصمة رقمية فريدة.
• يؤدي استخدام خوارزميات مثل SHA-256 إلى تقليل احتمالية التصادمات إلى أدنى مستوياتها.
• يتحسن أداء البرنامج ليصبح زمن التشغيل خطيًا O(n) مما يسمح لنا بمعالجة كميات هائلة من البيانات في وقت قياسي.

اقرأ أيضًا

• تطوير مفسر بايثون Python Interpreter
• بناء لعبة رسومية باستخدام بايثون ووحدة الألعاب Pygame
• أهم الأسئلة النظرية التي قد تطرح في المقابلات لتوظيف مطور بايثون

ترجمة -بتصرف- للفصل Chapter 3: Finding Duplicate Files من كتاب Software Design by Example.

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

كتب Ned Batchelder و Allison Kaptur مفسر بايثون Byterun بناءً على عمل Paul Swartz، وبنيته مماثلة لمفسر بايثون الأساسي CPython، لذا سيساعدنا فهم مفسر Byterun على فهم المفسرات وخاصةً مفسر CPython شائع الاستخدام. يستطيع مفسر Byterun تشغيل معظم برامج بايثون البسيطة بالرغم من عدد سطور شيفرته القصير.

مفسر بايثون

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

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

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

تطوير مفسر بايثون باستخدام بايثون

Byterun هو مفسر بايثون مكتوب بلغة بايثون نفسها كما هو الحال مع مصرِّف C المستخدَم على نطاق واسع gcc المكتوب بلغة C، ولكن يمكننا كتابة مفسر بايثون بأي لغة تقريبًا.

توجد مزايا وعيوب لكتابة مفسر بايثون باستخدام بايثون، فالعيب الأكبر هو السرعة، إذ يُعَد تنفيذ الشيفرة البرمجية في Byterun أبطأ بكثير من تنفيذها في مفسر CPython المكتوب بلغة C، ولكن صُمِّم مفسر Byterun في الأصل كتطبيق تعليمي، لذا لم تكن السرعة ذات أهمية كبيرة.

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

بناء مفسر

لنتعرف أولًا على كيفية عمل مفسر بايثون قبل البدء بشيفرة Byterun البرمجية، حيث يُعَد مفسر بايثون آلة افتراضية Virtual Machine، أي أنه برنامج يحاكي حاسوبًا حقيقيًا، وتكون هذه الآلة الافتراضية عبارة عن آلة مكدس Stack Machine، أي أنها تعالج عدة مكدسات لأداء عملياتها على عكس آلة التسجيل Register Machine التي تكتب وتقرأ من مواقع ذاكرة معينة.

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

بناء مفسر بسيط

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

• LOAD_VALUE
• ADD_TWO_VALUES
• PRINT_ANSWER

لن نهتم في هذا المقال بمحلل المفردات والمحلل والمصرِّف، وبالتالي لن نهتم بكيفية توليد مجموعات التعليمات. لنفترض كتابة العملية ‎7 + 5‎ التالية، حيث يصدر المصرِّف مجموعة من التعليمات الثلاث السابقة، أو إذا كان لدينا المصرِّف الصحيح، فيمكننا الكتابة بصيغة لغة Lisp المُحوَّلة إلى مجموعة التعليمات نفسها. لا يهتم المفسر بذلك، فما يهمه هو أن يحصل على تنسيق مناسب من هذه التعليمات.

7 + 5

وستنتج العملية السابقة مجموعة التعليمات التالية:

what_to_execute = {
    "instructions": [("LOAD_VALUE", 0),  # العدد الأول
                     ("LOAD_VALUE", 1),  # العدد الثاني
                     ("ADD_TWO_VALUES", None),
                     ("PRINT_ANSWER", None)],
    "numbers": [7, 5] }

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

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

ولكن لماذا لا نضع الأعداد في التعليمات مباشرةً؟ حسنًا، لنفترض أننا نريد جمع سلاسل نصية بدلًا من جمع أعداد، إذ لن نرغب في جعل التعليمات كبيرة الحجم عندما نضع هذه السلاسل النصية مع التعليمات، وتسمح هذه الطريقة بالحصول على نسخة واحدة فقط من كل كائن نحتاجه، وبالتالي يمكن أن تكون الأعداد "numbers" هي [7] فقط لإجراء العملية 7 + 7 مثلًا.

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

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

class Interpreter:
    def __init__(self):
        # مكدّس لتخزين القيم أثناء التنفيذ
        self.stack = []

    def LOAD_VALUE(self, number):
        # تحميل/إدخال قيمة إلى المكدّس
        self.stack.append(number)

    def PRINT_ANSWER(self):
        # إخراج آخر قيمة من المكدّس وطباعتها
        answer = self.stack.pop()
        print(answer)

    def ADD_TWO_VALUES(self):
        # سحب آخر قيمتين من المكدّس ثم جمعهما وإرجاع الناتج إلى المكدّس
        first_num = self.stack.pop()
        second_num = self.stack.pop()
        total = first_num + second_num
        self.stack.append(total)

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

def run_code(self, what_to_execute):
    # استخراج قائمة التعليمات وقائمة القيم العددية من المدخل
    instructions = what_to_execute["instructions"]
    numbers = what_to_execute["numbers"]

    # تنفيذ التعليمات بالترتيب (كمفسّر بسيط)
    for each_step in instructions:
        # كل خطوة تحتوي اسم التعليمة ووسيطها إن وجد
        instruction, argument = each_step

        if instruction == "LOAD_VALUE":
            # جلب قيمة عددية حسب الفهرس ثم وضعها في المكدّس
            number = numbers[argument]
            self.LOAD_VALUE(number)

        elif instruction == "ADD_TWO_VALUES":
            # جمع آخر قيمتين في المكدّس ثم وضع الناتج في المكدّس
            self.ADD_TWO_VALUES()

        elif instruction == "PRINT_ANSWER":
            # طباعة آخر قيمة في المكدّس (غالبًا النتيجة)
            self.PRINT_ANSWER()

يمكننا اختبار ذلك من خلال إنشاء نسخة من الكائن ثم استدعاء التابع run_code مع مجموعة التعليمات الخاصة بجمع العددين ‎7 + 5‎، وستظهر الإجابة 12 بالتأكيد.

  interpreter = Interpreter()
    interpreter.run_code(what_to_execute)

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

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

 what_to_execute = {
        "instructions": [("LOAD_VALUE", 0),
                         ("LOAD_VALUE", 1),
                         ("ADD_TWO_VALUES", None),
                         ("LOAD_VALUE", 2),
                         ("ADD_TWO_VALUES", None),
                         ("PRINT_ANSWER", None)],
        "numbers": [7, 5, 8] }

يمكننا تصور كيفية توسيع هذه البنية من خلال إضافة توابع إلى كائن المفسر لإجراء العديد من العمليات الأخرى مع وجود مصرِّف يزودنا بمجموعات تعليمات ذات تنسيق مناسب.

المتغيرات

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

>>> def s():
...     a = 1
...     b = 2
...     print(a + b)

# هذا قاموس يصف بايت كود مبسّط للدالة s: ماذا ننفّذ وبأي ترتيب

what_to_execute = {
    # قائمة التعليمات بالترتيب
    # كل عنصر عبارة عن: (اسم التعليمة، وسيطها) والوسيط قد يكون فهرسًا أو لا يوجد
    "instructions": [
        ("LOAD_VALUE", 0),         # وضع القيمة الأولى في المكدّس
        ("STORE_NAME", 0),         # تخزين أعلى قيمة في المكدّس داخل المتغير الأول
        ("LOAD_VALUE", 1),         # وضع القيمة الثانية في المكدّس
        ("STORE_NAME", 1),         # تخزين أعلى قيمة في المكدّس داخل المتغير الثاني
        ("LOAD_NAME", 0),          # تحميل قيمة المتغير الأول إلى المكدّس
        ("LOAD_NAME", 1),          # تحميل قيمة المتغير الثاني إلى المكدّس
        ("ADD_TWO_VALUES", None),  # جمع آخر قيمتين في المكدّس ووضع الناتج في المكدّس
        ("PRINT_ANSWER", None)     # طباعة آخر قيمة في المكدّس
    ],

    # قائمة القيم العددية التي تشير إليها التعليمات عبر فهارس
    "numbers": [1, 2],

    # قائمة أسماء المتغيرات التي تشير إليها التعليمات عبر فهارس
    "names": ["a", "b"]
}

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

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

class Interpreter:
    def __init__(self):
        # مكدّس لتخزين القيم مؤقتًا أثناء التنفيذ
        self.stack = []
        # بيئة لحفظ قيم المتغيرات (اسم المتغير ← قيمته)
        self.environment = {}

    def STORE_NAME(self, name):
        # أخذ آخر قيمة من المكدّس وتخزينها باسم متغير
        val = self.stack.pop()
        self.environment[name] = val

    def LOAD_NAME(self, name):
        # جلب قيمة متغير ووضعها في المكدّس
        val = self.environment[name]
        self.stack.append(val)

    def parse_argument(self, instruction, argument, what_to_execute):
        """تفسير معنى الوسيط لكل تعليمة"""
        # تعليمات تستخدم قائمة الأرقام
        numbers = ["LOAD_VALUE"]
        # تعليمات تستخدم قائمة أسماء المتغيرات
        names = ["LOAD_NAME", "STORE_NAME"]

        if instruction in numbers:
            # تحويل الفهرس إلى رقم فعلي
            argument = what_to_execute["numbers"][argument]
        elif instruction in names:
            # تحويل الفهرس إلى اسم متغير فعلي
            argument = what_to_execute["names"][argument]

        return argument

    def run_code(self, what_to_execute):
        # أخذ التعليمات وتنفيذها بالترتيب
        instructions = what_to_execute["instructions"]
        for each_step in instructions:
            # كل خطوة: (اسم التعليمة، وسيطها)
            instruction, argument = each_step
            # تحويل الوسيط من فهرس إلى قيمة مفهومة
            argument = self.parse_argument(instruction, argument, what_to_execute)

            if instruction == "LOAD_VALUE":
                # إدخال رقم إلى المكدّس
                self.LOAD_VALUE(argument)
            elif instruction == "ADD_TWO_VALUES":
                # جمع آخر قيمتين في المكدّس
                self.ADD_TWO_VALUES()
            elif instruction == "PRINT_ANSWER":
                # طباعة آخر قيمة في المكدّس
                self.PRINT_ANSWER()
            elif instruction == "STORE_NAME":
                # تخزين قيمة في متغير
                self.STORE_NAME(argument)
            elif instruction == "LOAD_NAME":
                # تحميل قيمة متغير إلى المكدّس
                self.LOAD_NAME(argument)

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

def execute(self, what_to_execute):
    # جلب قائمة التعليمات
    instructions = what_to_execute["instructions"]

    # تنفيذ التعليمات خطوة بخطوة
    for each_step in instructions:
        # استخراج اسم التعليمة ووسيطها
        instruction, argument = each_step

        # تحويل الوسيط من فهرس إلى قيمة فعلية (رقم أو اسم متغير)
        argument = self.parse_argument(instruction, argument, what_to_execute)

        # الحصول على الدالة المطابقة لاسم التعليمة داخل هذا الصنف
        bytecode_method = getattr(self, instruction)

        # تنفيذ التعليمة: إن لم يكن لها وسيط ننفذها مباشرة، وإلا نمرر الوسيط
        if argument is None:
            bytecode_method()
        else:
            bytecode_method(argument)

بناء بايت كود حقيقي في بايثون

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

>>> def cond():
...     x = 3                 
...     if x < 5:             
...         return 'yes'      
...     else:                 
...         return 'no'       

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

>>> cond.__code__.co_code  # الوصول إلى البايت كود الخام للدالة على شكل بايتات
b'd\x01\x00}\x00\x00|\x00\x00d\x02\x00k\x00\x00r\x16\x00d\x03\x00Sd\x04\x00Sd\x00
   \x00S'                  # هذه هي البايتات نفسها التي ينفّذها مفسّر بايثون

>>> list(cond.__code__.co_code)  # تحويل نفس البايتات إلى قائمة أعداد لقراءتها بسهولة
[100, 1, 0, 125, 0, 0, 124, 0, 0, 100, 2, 0, 107, 0, 0, 114, 22, 0, 100, 3, 0, 83, 
 100, 4, 0, 83, 100, 0, 0, 83]  # كل رقم يمثّل جزءًا من تعليمة أو وسيطها داخل البايت كود

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

>>> dis.dis(cond)  # عرض البايت كود بصيغة مقروءة (تعليمات + عناوين)

  2           0 LOAD_CONST               1 (3)      # تحميل الثابت رقم 1 (القيمة 3)
              3 STORE_FAST               0 (x)      # تخزين القيمة في المتغير المحلي رقم 0 (x)

  3           6 LOAD_FAST                0 (x)      # x تحميل قيمة المتغير المحلي 
              9 LOAD_CONST               2 (5)      # تحميل الثابت رقم 2 (القيمة 5)
             12 COMPARE_OP               0 (<)      # (<) مقارنة القيمتين باستخدام العامل
             15 POP_JUMP_IF_FALSE       22          # إذا كانت نتيجة الشرط غير صحيحة اقفز إلى العنوان 22

  4          18 LOAD_CONST               3 ('yes')  # 'yes' تحميل الثابت 
             21 RETURN_VALUE                        # إرجاع القيمة

  6     >>   22 LOAD_CONST               4 ('no')   # 'no' تحميل الثابت
             25 RETURN_VALUE                        # إرجاع القيمة
             26 LOAD_CONST               0 (None)   # قيمة افتراضية عند عدم الإرجاع صراحة
             29 RETURN_VALUE                        

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

تمثل البايتات الستة الأولى من البايت كود‎ [100, 1, 0, 125, 0, 0] تعليمتين مع وسطائهما، ويمكننا استخدام dis.opname التي تربط البايتات مع سلاسل نصية مفهومة لمعرفة ما تعنيه التعليمتان 100 و 125 كما يلي:

>>> dis.opname[100]        # إرجاع اسم التعليمة المقابل لرقم العملية 100
'LOAD_CONST'               # الرقم 100 يعني: تحميل ثابت

>>> dis.opname[125]        # إرجاع اسم التعليمة المقابل لرقم العملية 125
'STORE_FAST'               # الرقم 125 يعني: تخزين قيمة في متغير محلي

يمثل البايتان الثاني والثالث ‎1 و 0‎ وسطاء التعليمة LOAD_CONST، ويمثل البايتان الخامس والسادس ‎0 و 0‎ وسطاء التعليمة STORE_FAST، إذ تحتاج التعليمة LOAD_CONST إلى معرفة مكان العثور على الثابت لتحميله، وتحتاج التعليمة STORE_FAST إلى العثور على الاسم لتخزينه. تمثل هذه البايتات الستة السطر الأول من الشيفرة البرمجية x = 3، حيث تقابل التعليمة LOAD_CONST في بايثون التعليمة LOAD_VALUE في المفسر السابق، وتقابل التعليمة LOAD_FAST التعليمة LOAD_NAME.

يُستخدَم بايتان لكل وسيط، لأنه إذا استخدم بايثون بايتًا واحدًا فقط لتحديد مكان الثوابت والأسماء بدلًا من استخدام بايتين، فلن نتمكن إلا من الحصول على 256 اسمٍ أو ثابت مرتبط بكائن شيفرة واحد، بينما يمكن الحصول على ما يصل إلى مربع العدد 256 أو 65536 عند استخدام بايتين.

التعليمات الشرطية والحلقات

نفّذَ المفسر حتى الآن الشيفرة البرمجية ببساطة من خلال تنفيذ التعليمات واحدة تلو الأخرى، ولكن قد يشكّل ذلك مشكلة، لأننا في أغلب الاحيان نريد تكرار تنفيذ تعليمات معينة، أو قد نرغب في تخطي بعض التعليمات في شروط محددة، لذا يجب أن يكون المفسر قادرًا على التنقل عبر مجموعة التعليمات للسماح بكتابة الحلقات والتعليمات الشرطية if في الشيفرة البرمجية، حيث يتعامل بايثون مع الحلقات والتعليمات الشرطية باستخدام تعليمات GOTO في البايت كود. لنطلع الآن على تفكيك الدالة cond مرة أخرى:

>>> dis.dis(cond)  # عرض تعليمات الدالة بصيغة مقروءة (العنوان + اسم التعليمة + الوسيط)

  2           0 LOAD_CONST               1 (3)      # تحميل الثابت 3 إلى المكدّس
              3 STORE_FAST               0 (x)      # x تخزين القيمة في المتغير المحلي 

  3           6 LOAD_FAST                0 (x)      # تحميل قيمة x إلى المكدّس
              9 LOAD_CONST               2 (5)      # تحميل الثابت 5 إلى المكدّس
             12 COMPARE_OP               0 (<)      # مقارنة: هل x أصغر من 5؟
             15 POP_JUMP_IF_FALSE       22          # إذا كانت المقارنة خطأ انتقل إلى العنوان 22

  4          18 LOAD_CONST               3 ('yes')  # تحميل 'yes' (فرع if)
             21 RETURN_VALUE                        # إرجاع القيمة وإنهاء الدالة

  6     >>   22 LOAD_CONST               4 ('no')   # تحميل 'no' (فرع else)
             25 RETURN_VALUE                        # إرجاع القيمة وإنهاء الدالة
             26 LOAD_CONST               0 (None)   # تحميل None كقيمة افتراضية
             29 RETURN_VALUE                        # إرجاع None (مسار افتراضي/احتياطي)

تُصرَّف التعليمة الشرطية ‎if x < 5‎ في السطر 3 من الشيفرة البرمجية إلى أربع تعليمات هي: LOAD_FAST و LOAD_CONST و COMPARE_OP و POP_JUMP_IF_FALSE، حيث يولد الشرط ‎x < 5‎ الشيفرة البرمجية لتحميل x وتحميل القيمة 5 ومقارنة القيمتين. تكون التعليمة POP_JUMP_IF_FALSE مسؤولة عن تنفيذ تعليمة if، إذ تؤدي هذه التعليمة إلى سحب القيمة العليا من مكدس المفسر، حيث إذا كانت القيمة صحيحة، فلن يحدث شيء، ويمكن أن تكون القيمة صحيحة دون أن تكون كائن True حرفيًا، بينما إذا كانت القيمة خاطئة، فسينتقل المفسر إلى تعليمة أخرى.

تسمى التعليمة التي يجب الوصول إليها بهدف عملية القفز Jump Target، وتكون وسيطًا للتعليمة POP_JUMP، فهدف القفز هو 22 في مثالنا، والتعليمة ذات الفهرس 22 هي LOAD_CONST عند السطر 6، حيث تضع وحدة dis الرمز << على أهداف القفز. إذا كانت نتيجة الشرط ‎x < 5‎ خاطئة، فسيقفز المفسر إلى السطر 6 مباشرةً return "no"‎‎ مع تجاوز السطر 4 الذي هو ‎return "yes"، وبالتالي يستخدم المفسر تعليمات القفز للتخطي الانتقائي لأجزاء من مجموعة التعليمات.

تعتمد حلقات Loops بايثون على القفز، فمثلًا يولّد السطر while x < 5 في البايت كود التالي بايت كود متطابقًا تقريبًا مع بايت كود التعليمة if x < 10، حيث تُطبَّق المقارنة في كلتا الحالتين ثم تتحكم التعليمة POP_JUMP_IF_FALSE بالتعليمة التالية التي ستُنفَّذ. ترسل التعليمة JUMP_ABSOLUTE في نهاية السطر 4 الذي يمثل نهاية جسم الحلقة دائمًا المفسر مرة أخرى إلى التعليمة 9 في أعلى الحلقة، وتؤدي التعليمة POP_JUMP_IF_FALSE إلى قفز المفسر إلى ما بعد نهاية الحلقة إلى التعليمة 34 عندما يصبح الشرط x < 5‎ خاطئًا.

>>> def loop():
...      x = 1                  
...      while x < 5:          
...          x = x + 1             
...      return x            
...
>>> dis.dis(loop)  # عرض تعليمات الدالة بصيغة مقروءة

  2           0 LOAD_CONST               1 (1)      # تحميل الثابت 1 إلى المكدّس
              3 STORE_FAST               0 (x)      # x تخزينه في المتغير المحلي 

  3           6 SETUP_LOOP              26 (to 35)  # تجهيز إطار الحلقة (بداية/نهاية ومسار الخروج)
        >>    9 LOAD_FAST                0 (x)      # تحميل x لفحص شرط الحلقة
             12 LOAD_CONST               2 (5)      # تحميل الثابت 5
             15 COMPARE_OP               0 (<)      # مقارنة: هل x أصغر من 5؟
             18 POP_JUMP_IF_FALSE       34          # إذا كان الشرط غير صحيح اقفز إلى نهاية الحلقة (العنوان 34)

  4          21 LOAD_FAST                0 (x)      # تحميل x لتنفيذ جسم الحلقة
             24 LOAD_CONST               1 (1)      # تحميل الثابت 1
             27 BINARY_ADD                          # (x + 1) جمع القيمتين 
             28 STORE_FAST               0 (x)      # x تخزين الناتج في 
             31 JUMP_ABSOLUTE            9          # الرجوع لبداية فحص الشرط (العنوان 9)
        >>   34 POP_BLOCK                          # إنهاء إطار الحلقة بعد الخروج منها

  5     >>   35 LOAD_FAST                0 (x)      # تحميل x بعد انتهاء الحلقة
             38 RETURN_VALUE                        # x إرجاع 

استكشاف البايت كود

يمكننا تجربة تشغيل dis.dis مع الدوال التي نكتبها للإجابة عن الأسئلة التالية:

• ما الفرق بين حلقة for وحلقة while بالنسبة لمفسر بايثون؟
• كيف يمكننا كتابة دوال مختلفة تولد بايت كود متطابق؟
• كيف تعمل تعليمة elif، وما هو استيعاب القوائم List Comprehensions؟

الإطارات Frames

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

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

توجد الإطارات في مكدس الاستدعاءات Call Stack الذي هو مكدس مختلف تمامًا عن المكدس الذي تحدثنا عنه سابقًا، فمكدس الاستدعاءات هو مكدسٌ رأيناه مسبقًا في عمليات التتبع العكسي Tracebacks للاستثناءات، إذ يقابل كل سطر في عملية التتبع العكسي يبدأ بعبارة ‎"File 'program.py', line 10"‎‎ إطارًا واحدًا في مكدس الاستدعاءات. نسمي المكدس الذي يتعامل معه المفسر أثناء تنفيذ البايت كود بمكدس البيانات Data Stack. يوجد مكدس ثالث اسمه مكدس الكتل Block Stack، حيث تُستخدَم الكتل لأنواع معينة من تدفق التحكم مثل التكرار ضمن حلقة ومعالجة الاستثناءات، ويكون لكل إطارٍ في مكدس الاستدعاءات مكدس بيانات ومكدس كتل خاص به.

لنفترض مثلًا أن مفسر بايثون ينفّذ حاليًا السطر المحدد بالرقم 3، حيث يكون المفسر عند استدعاء الدالة foo التي تستدعي الدالة bar بدورها. يوضح الرسم البياني الآتي مخطط مكدس الاستدعاءات للإطارات ومكدسات الكتل ومكدسات البيانات، وتعَد هذه الشيفرة البرمجية مكتوبة بطريقة مشابهة لجلسة REPL، لذلك جرى تعريف الدوال المطلوبة أولًا. ينفذ المفسر حاليًا الدالة foo()‎‎ التي تصل بعد ذلك إلى جسم الدالة foo ثم إلى bar كما يلي:

>>> def bar(y):
...     z = y + 3             # (3) داخل الدالة bar: حساب z بجمع y مع 3
...     return z              
...
>>> def foo():
...     a = 1                 
...     b = 2                 
...     return a + bar(b)     # (2) 
...
>>> foo()                     # (1) استدعاء الدالة foo لتنفيذ ما بداخلها
3                             # foo الناتج النهائي بعد تنفيذ

يكون المفسر حاليًا عند استدعاء الدالة bar، وتوجد ثلاثة إطارات في مكدس الاستدعاءات هي: إطار على مستوى الوحدة، وإطار للدالة foo، وإطار للدالة bar كما هو موضح في الشكل السابق، حيث تعود الدالة bar ثم يُخرَج ويُهمَل الإطار المرتبط بها من مكدس الاستدعاءات. تخبر تعليمة البايت كود RETURN_VALUE المفسرَ بتمرير قيمةٍ بين الإطارات، حيث يخرِج أولًا القيمة العليا من مكدس البيانات الخاص بالإطار العلوي من مكدس الاستدعاءات، ثم يخرِج الإطار بالكامل من مكدس الاستدعاءات ويتخلص منه، وتُدفَع أخيرًا القيمة إلى مكدس البيانات في الإطار التالي.

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

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

مفسر Byterun

تعرّفنا على بعض المفاهيم المتعلقة بمفسر بايثون ولنبدأ الآن بمفسر Byterun، حيث توجد أربعة أنواع من الكائنات في Byterun وهي:

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

الصنف VirtualMachine

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

class VirtualMachine(object):
    def __init__(self):
        self.frames = []   # مكدس استدعاءات الإطارات
        self.frame = None  # الإطار الحالي
        self.return_value = None
        self.last_exception = None

    def run_code(self, code, global_names=None, local_names=None):
        """ An entry point to execute code using the virtual machine."""
        frame = self.make_frame(code, global_names=global_names, 
                                local_names=local_names)
        self.run_frame(frame)

الصنف Frame

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

class Frame(object):
    def __init__(self, code_obj, global_names, local_names, prev_frame):
        self.code_obj = code_obj              # كائن الكود الذي سيتم تنفيذه
        self.global_names = global_names      # مساحة الأسماء العامة
        self.local_names = local_names        # مساحة الأسماء المحلية
        self.prev_frame = prev_frame          # الإطار السابق (للاستدعاءات المتداخلة)
        self.stack = []                       # مكدّس القيم أثناء التنفيذ

        if prev_frame:
            # وراثة مساحة الأسماء المضمنة من الإطار السابق
            self.builtin_names = prev_frame.builtin_names
        else:
            # في أول إطار: أخذ مساحة الأسماء المضمنة من __builtins__
            self.builtin_names = local_names['__builtins__']
            # إذا كانت كائنًا يحتوي قاموس أسماء، نستخدم قاموسه مباشرة
            if hasattr(self.builtin_names, '__dict__'):
                self.builtin_names = self.builtin_names.__dict__

        self.last_instruction = 0             # مؤشر آخر تعليمة تم تنفيذها
        self.block_stack = []                 # مكدّس الكتل (مثل الحلقات/الاستثناءات) لإدارة القفزات والخروج

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

class VirtualMachine(object):
    [... snip ...]

    # إنشاء إطار جديد للتنفيذ
    def make_frame(self, code, callargs={}, global_names=None, local_names=None):
        # تحديد مساحات الأسماء التي سيعمل عليها هذا الإطار
        if global_names is not None and local_names is not None:
            # عند تمريرهما معًا: اجعل المحلية نفس العامة (مساحة واحدة)
            local_names = global_names
        elif self.frames:
            # إذا كان هناك إطار حالي: ورّث العامة منه وابدأ محلية جديدة
            global_names = self.frame.global_names
            local_names = {}
        else:
            # إذا كان هذا أول إطار: أنشئ مساحة أسماء ابتدائية
            global_names = local_names = {
                '__builtins__': __builtins__,
                '__name__': '__main__',
                '__doc__': None,
                '__package__': None,
            }

        # إدخال معاملات الاستدعاء داخل المحلية
        local_names.update(callargs)

        # بناء الإطار وربطه بالإطار الحالي كإطار سابق
        frame = Frame(code, global_names, local_names, self.frame)
        return frame

    def push_frame(self, frame):
        # دفع الإطار الجديد ليصبح الإطار الحالي
        self.frames.append(frame)
        self.frame = frame

    def pop_frame(self):
        # إزالة الإطار الحالي والعودة للإطار السابق إن وُجد
        self.frames.pop()
        if self.frames:
            self.frame = self.frames[-1]
        else:
            self.frame = None

    def run_frame(self):
        pass
        # تنفيذ الإطار (سنضيف منطق التنفيذ لاحقًا)

الصنف Function

يُعَد تنفيذ الكائن Function معقدًا بعض الشيء، ولكن ليست معظم هذه التفاصيل ذات أهمية كبيرة لفهم المفسر، فالأمر المهم الذي يجب ملاحظته هو أن استدعاء دالة أو استدعاء التابع __call__ يؤدي إلى إنشاء كائن Frame جديد وبدء تشغيله.

class Function(object):
    """
    إنشاء كائن دالة قريب من دوال بايثون الحقيقية، بالشكل الذي يتوقعه المفسّر.
    """
    __slots__ = [
        'func_code', 'func_name', 'func_defaults', 'func_globals',
        'func_locals', 'func_dict', 'func_closure',
        '__name__', '__dict__', '__doc__',
        '_vm', '_func',
    ]  # تحديد الحقول المسموح بها لتقليل الذاكرة ومنع إضافة حقول عشوائية

    def __init__(self, name, code, globs, defaults, closure, vm):
        """لا تحتاج لفهم كل التفاصيل هنا لفهم المفسّر."""
        self._vm = vm                          # مرجع للآلة الافتراضية التي ستنفّذ هذه الدالة
        self.func_code = code                  # كائن الكود الخاص بالدالة
        self.func_name = self.__name__ = name or code.co_name  # اسم الدالة (المعطى أو من كائن الكود)
        self.func_defaults = tuple(defaults)   # القيم الافتراضية للوسطاء
        self.func_globals = globs              # مساحة الأسماء العامة
        self.func_locals = self._vm.frame.f_locals  # مساحة الأسماء المحلية من الإطار الحالي
        self.__dict__ = {}                     # قاموس خصائص إضافية للدالة
        self.func_closure = closure            # معلومات الإغلاق (إن وُجدت)
        self.__doc__ = code.co_consts[0] if code.co_consts else None  # نص التوثيق إن وُجد

        # إنشاء دالة بايثون "حقيقية" لنستفيد منها في ربط الوسطاء والتحقق من التواقيع
        kw = {
            'argdefs': self.func_defaults,     # تمرير القيم الافتراضية
        }
        if closure:
            # تجهيز خلايا للإغلاق بشكل صوري عند الحاجة
            kw['closure'] = tuple(make_cell(0) for _ in closure)

        self._func = types.FunctionType(code, globs, **kw)  # بناء كائن دالة بايثون من كائن الكود

    def __call__(self, *args, **kwargs):
        """عند استدعاء الدالة: ننشئ إطارًا جديدًا وننفّذه."""
        callargs = inspect.getcallargs(self._func, *args, **kwargs)  # ربط القيم بأسماء الوسطاء حسب التوقيع
        # استخدام هذا الربط لتمرير الوسطاء إلى الإطار الجديد
        frame = self._vm.make_frame(
            self.func_code, callargs, self.func_globals, {}
        )
        return self._vm.run_frame(frame)       # تنفيذ الإطار وإرجاع الناتج

def make_cell(value):
    """إنشاء خلية إغلاق حقيقية (لاستخراج مرجع خلية من إغلاق بايثون)."""
    # إنشاء دالة داخل دالة لإجبار بايثون على صنع خلية إغلاق
    fn = (lambda x: lambda: x)(value)
    return fn.__closure__[0]                  # استخراج الخلية نفسها

نعود الآن إلى كائن VirtualMachine، ونضيف بعض التوابع المساعدة لمعالجة مكدس البيانات، حيث يشغّل البايت كود الذي يعالج المكدس دائمًا مكدسَ بيانات الإطار الحالي، مما يؤدي إلى جعل تنفيذ تعليمة POP_TOP و LOAD_FAST وجميع التعليمات الأخرى التي تتعامل مع المكدس أكثر قابلية للقراءة.

class VirtualMachine(object):
    [... snip ...]

    # عمليات على مكدّس القيم

    def top(self):
        # إرجاع آخر قيمة في المكدّس دون إزالتها
        return self.frame.stack[-1]

    def pop(self):
        # إزالة آخر قيمة من المكدّس وإرجاعها
        return self.frame.stack.pop()

    def push(self, *vals):
        # إضافة قيمة أو أكثر إلى المكدّس
        self.frame.stack.extend(vals)

    def popn(self, n):
        """إزالة عدد من القيم من المكدّس وإرجاعها كقائمة."""
        if n:
            ret = self.frame.stack[-n:]    # أخذ آخر n قيم
            self.frame.stack[-n:] = []     # حذفها من المكدّس
            return ret
        else:
            # إذا كان صفرًا، نرجع قائمة فارغة
            return []

نحتاج إلى تابعين آخرين قبل تشغيل الإطار وهما: التابع الأول parse_byte_and_args الذي يأخذ بايت كود، ويتحقق من احتوائه على وسطاء، ويحلل هذه الوسطاء عند وجودها، ويحدّث هذا التابع سمة الإطار last_instruction التي هي مرجع إلى آخر تعليمة مُنفَّذة. يبلغ طول التعليمة بايتًا واحدًا عند عدم وجود وسيط، وثلاثة بايتات إذا كان لها وسيط بحيث يمثل البايتان الأخيران الوسيط. يعتمد معنى الوسيط لكل تعليمة على نوعها، فمثلًا يمثل وسيط التعليمة POP_JUMP_IF_FALSE هدف القفز، ويمثل وسيط التعليمة BUILD_LIST عدد العناصر في القائمة، ويمثل وسيط التعليمة LOAD_CONST فهرسًا في قائمة الثوابت.

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

class VirtualMachine(object):
    [... snip ...]

    def parse_byte_and_args(self):
        f = self.frame
        opoffset = f.last_instruction
        byteCode = f.code_obj.co_code[opoffset]
        f.last_instruction += 1
        byte_name = dis.opname[byteCode]
        if byteCode >= dis.HAVE_ARGUMENT:
            # فهرس إلى البايت كود
            arg = f.code_obj.co_code[f.last_instruction:f.last_instruction+2]  
            f.last_instruction += 2   # تقدّم مؤشر التعليمة
            arg_val = arg[0] + (arg[1] * 256)
            if byteCode in dis.hasconst:   # البحث عن ثابت
                arg = f.code_obj.co_consts[arg_val]
            elif byteCode in dis.hasname:  # البحث عن اسم
                arg = f.code_obj.co_names[arg_val]
            elif byteCode in dis.haslocal: # البحث عن اسم محلي
                arg = f.code_obj.co_varnames[arg_val]
            elif byteCode in dis.hasjrel:  # حساب القفزة النسبية
                arg = f.last_instruction + arg_val
            else:
                arg = arg_val
            argument = [arg]
        else:
            argument = []

        return byte_name, argument

التابع الثاني هو dispatch الذي يبحث عن العمليات لتعليمة معينة وينفّذها. يُنفَّذ هذا التابع للإرسال في مفسّر CPython باستخدام تعليمة switch ضخمة بحجم 1500 سطر، ولكن ستكون الأمور أفضل بكثير عند كتابة الشيفرة البرمجية باستخدام بايثون، حيث سنعرّف تابعًا لكل اسم تعليمة ثم نستخدم الدالة getattr للبحث عنه، فمثلًا إذا كان اسم التعليمة FOO_BAR كما في مثالنا للمفسر البسيط السابق، فسيكون اسم التابع المقابل هو byte_FOO_BAR. يعيد كل تابع بايت كود القيمةَ None أو سلسلةً نصية اسمها why تمثل جزءًا إضافيًا من الحالة التي قد يحتاجها المفسّر في بعض الحالات. تُستخدَم هذه القيم المعادة لتوابع التعليمات كمؤشرات داخلية فقط لحالة المفسّر، لذا يجب عدم الخلط بينها وبين القيم المعادة من إطارات التنفيذ.

class VirtualMachine(object):
    [... snip ...]

    def dispatch(self, byte_name, argument):
        """ Dispatch by bytename to the corresponding methods.
        Exceptions are caught and set on the virtual machine."""

        # نحتاج إلى تتبع سبب فك مكدس الكتل لاحقًا
        why = None
        try:
            bytecode_fn = getattr(self, 'byte_%s' % byte_name, None)
            if bytecode_fn is None:
                if byte_name.startswith('UNARY_'):
                    self.unaryOperator(byte_name[6:])
                elif byte_name.startswith('BINARY_'):
                    self.binaryOperator(byte_name[7:])
                else:
                    raise VirtualMachineError(
                        "unsupported bytecode type: %s" % byte_name
                    )
            else:
                why = bytecode_fn(*argument)
        except:
            # التعامل مع الاستثناءات التي واجهتنا أثناء تنفيذ العملية
            self.last_exception = sys.exc_info()[:2] + (None,)
            why = 'exception'

        return why

    def run_frame(self, frame):
        """Run a frame until it returns (somehow).
        Exceptions are raised, the return value is returned.
        """
        self.push_frame(frame)
        while True:
            byte_name, arguments = self.parse_byte_and_args()

            why = self.dispatch(byte_name, arguments)

            # التعامل مع إدارة الكتل التي نحتاجها
            while why and frame.block_stack:
                why = self.manage_block_stack(why)

            if why:
                break

        self.pop_frame()

        if why == 'exception':
            exc, val, tb = self.last_exception
            e = exc(val)
            e.__traceback__ = tb
            raise e

        return self.return_value

الصنف Block

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

يتتبع المفسر هذه المعلومة الإضافية من خلال وضع رايةٍ Flag للإشارة إلى حالتها، حيث تكون هذه الراية متغيرًا بالاسم why، والذي يمكن أن تكون قيمته None أو إحدى السلاسل النصية "continue" أو "break" أو "exception" أو "return"، إذ تشير هذه القيم إلى كيفية التعامل مع مكدس الكتل ومكدس البيانات، حيث إذا كان الجزء العلوي من مكدس الكتل في مثالنا هو كتلة loop وكانت قيمة why هي continue، فيجب أن يبقى كائن التكرار في مكدس البيانات، ولكن إذا كانت قيمة why هي break، فيجب إخراجه من هذا المكدس.

Block = collections.namedtuple("Block", "type, handler, stack_height")  # بنية خفيفة لتمثيل كتلة تنفيذ (نوعها + وجهة القفز + ارتفاع المكدّس)

class VirtualMachine(object):
    [... snip ...]

    # معالجة مكدّس الكتل
    def push_block(self, b_type, handler=None):
        # حفظ ارتفاع مكدّس القيم عند دخول الكتلة لنستطيع تنظيفه عند الخروج
        stack_height = len(self.frame.stack)
        self.frame.block_stack.append(Block(b_type, handler, stack_height))  # دفع كتلة جديدة إلى مكدّس الكتل

    def pop_block(self):
        # إزالة أحدث كتلة من مكدّس الكتل
        return self.frame.block_stack.pop()

    def unwind_block(self, block):
        """تنظيف القيم من مكدّس البيانات بما يناسب الكتلة."""
        if block.type == 'except-handler':
            # في معالجة الاستثناء: تُحجز ثلاث قيم عادة (نوع/قيمة/تتبّع)
            offset = 3
        else:
            offset = 0

        # حذف أي قيم زائدة في مكدّس القيم للوصول لارتفاع الكتلة وقت الدخول
        while len(self.frame.stack) > block.level + offset:
            self.pop()

        if block.type == 'except-handler':
            # استرجاع معلومات الاستثناء لتخزينها كآخر استثناء
            traceback, value, exctype = self.popn(3)
            self.last_exception = exctype, value, traceback

    def manage_block_stack(self, why):
        """تقرير ما يجب فعله عند الخروج من كتلة بسبب سبب معيّن (كسر/متابعة/استثناء/إرجاع)."""
        frame = self.frame
        block = frame.block_stack[-1]  # النظر إلى أحدث كتلة دون حذفها

        if block.type == 'loop' and why == 'continue':
            # متابعة الحلقة: قفز إلى بداية الحلقة (العنوان مخزّن في return_value هنا)
            self.jump(self.return_value)
            why = None
            return why

        # الخروج من الكتلة: حذفها ثم تنظيف مكدّس القيم المرتبط بها
        self.pop_block()
        self.unwind_block(block)

        if block.type == 'loop' and why == 'break':
            # كسر الحلقة: القفز إلى نهاية الحلقة (المعالج هو وجهة الخروج)
            why = None
            self.jump(block.handler)
            return why

        if (block.type in ['setup-except', 'finally'] and why == 'exception'):
            # عند وقوع استثناء: تجهيز كتلة معالجة الاستثناء ودفع معلوماته للمكدّس ثم القفز لمعالج الاستثناء
            self.push_block('except-handler')
            exctype, value, tb = self.last_exception
            self.push(tb, value, exctype)
            self.push(tb, value, exctype)  # تُدفع مرتين لتوافق تهيئة بايثون في هذا التبسيط
            why = None
            self.jump(block.handler)
            return why

        elif block.type == 'finally':
            # عند finally: نمرّر سبب الخروج، وأحيانًا قيمة الإرجاع/المتابعة
            if why in ('return', 'continue'):
                self.push(self.return_value)

            self.push(why)  # حفظ سبب الخروج ليُستخدم داخل finally

            why = None
            self.jump(block.handler)  # الانتقال إلى بداية finally
            return why

        # إن لم تُعالج الحالة هنا، نُعيد السبب كما هو
        return why

التعليمات

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

class VirtualMachine(object):
    [... snip ...]

    ## معالجة المكدس

    def byte_LOAD_CONST(self, const):
        # وضع ثابت (قيمة جاهزة) في المكدّس
        self.push(const)

    def byte_POP_TOP(self):
        # حذف أعلى قيمة من المكدّس دون استخدامها
        self.pop()

    ## الأسماء
    def byte_LOAD_NAME(self, name):
        # تحميل اسم: نبحث عنه محليًا ثم عالميًا ثم ضمن الأسماء المضمنة
        frame = self.frame
        if name in frame.f_locals:
            val = frame.f_locals[name]
        elif name in frame.f_globals:
            val = frame.f_globals[name]
        elif name in frame.f_builtins:
            val = frame.f_builtins[name]
        else:
            # إذا لم يُعثر عليه في أي مكان نرمي خطأ اسم غير معرّف
            raise NameError("name '%s' is not defined" % name)
        self.push(val)

    def byte_STORE_NAME(self, name):
        # تخزين قيمة في اسم محلي
        self.frame.f_locals[name] = self.pop()

    def byte_LOAD_FAST(self, name):
        # تحميل متغير محلي "سريع" (يجب أن يكون قد أُسنِد مسبقًا)
        if name in self.frame.f_locals:
            val = self.frame.f_locals[name]
        else:
            # استخدام متغير محلي قبل إسناده
            raise UnboundLocalError(
                "local variable '%s' referenced before assignment" % name
            )
        self.push(val)

    def byte_STORE_FAST(self, name):
        # تخزين قيمة في متغير محلي "سريع"
        self.frame.f_locals[name] = self.pop()

    def byte_LOAD_GLOBAL(self, name):
        # تحميل اسم من المجال العام أو من الأسماء المضمنة
        f = self.frame
        if name in f.f_globals:
            val = f.f_globals[name]
        elif name in f.f_builtins:
            val = f.f_builtins[name]
        else:
            raise NameError("global name '%s' is not defined" % name)
        self.push(val)

    ## المعاملات

    BINARY_OPERATORS = {
        'POWER':    pow,
        'MULTIPLY': operator.mul,
        'FLOOR_DIVIDE': operator.floordiv,
        'TRUE_DIVIDE':  operator.truediv,
        'MODULO':   operator.mod,
        'ADD':      operator.add,
        'SUBTRACT': operator.sub,
        'SUBSCR':   operator.getitem,
        'LSHIFT':   operator.lshift,
        'RSHIFT':   operator.rshift,
        'AND':      operator.and_,
        'XOR':      operator.xor,
        'OR':       operator.or_,
    }  # جدول يربط اسم العملية بدالة تنفيذها

    def binaryOperator(self, op):
        # أخذ قيمتين من المكدّس وتنفيذ العملية الثنائية ثم إعادة الناتج للمكدّس
        x, y = self.popn(2)
        self.push(self.BINARY_OPERATORS[op](x, y))

    COMPARE_OPERATORS = [
        operator.lt,
        operator.le,
        operator.eq,
        operator.ne,
        operator.gt,
        operator.ge,
        lambda x, y: x in y,
        lambda x, y: x not in y,
        lambda x, y: x is y,
        lambda x, y: x is not y,
        lambda x, y: issubclass(x, Exception) and issubclass(x, y),
    ]  # جدول عمليات المقارنة حسب رقم العملية

    def byte_COMPARE_OP(self, opnum):
        # مقارنة قيمتين من المكدّس حسب رقم عملية المقارنة
        x, y = self.popn(2)
        self.push(self.COMPARE_OPERATORS[opnum](x, y))

    ## السمات والفهرسة

    def byte_LOAD_ATTR(self, attr):
        # قراءة سمة من كائن (مثل obj.attr)
        obj = self.pop()
        val = getattr(obj, attr)
        self.push(val)

    def byte_STORE_ATTR(self, name):
        # تعيين سمة لكائن (مثل obj.attr = val)
        val, obj = self.popn(2)
        setattr(obj, name, val)

    ## البناء

    def byte_BUILD_LIST(self, count):
        # بناء قائمة من عدد عناصر مأخوذة من المكدّس
        elts = self.popn(count)
        self.push(elts)

    def byte_BUILD_MAP(self, size):
        # إنشاء قاموس فارغ (الحجم هنا غير مستخدم في هذا التبسيط)
        self.push({})

    def byte_STORE_MAP(self):
        # إضافة (مفتاح، قيمة) إلى قاموس موجود ثم إرجاعه للمكدّس
        the_map, val, key = self.popn(3)
        the_map[key] = val
        self.push(the_map)

    def byte_LIST_APPEND(self, count):
        # إضافة عنصر إلى قائمة موجودة أعمق في المكدّس
        val = self.pop()
        the_list = self.frame.stack[-count]  # الوصول للقائمة دون سحبها
        the_list.append(val)

    ## القفزات

    def byte_JUMP_FORWARD(self, jump):
        # الانتقال إلى تعليمة أخرى للأمام
        self.jump(jump)

    def byte_JUMP_ABSOLUTE(self, jump):
        # الانتقال إلى تعليمة برقم محدد
        self.jump(jump)

    def byte_POP_JUMP_IF_TRUE(self, jump):
        # سحب قيمة شرطية: إذا كانت صحيحة نقفز
        val = self.pop()
        if val:
            self.jump(jump)

    def byte_POP_JUMP_IF_FALSE(self, jump):
        # سحب قيمة شرطية: إذا كانت خاطئة نقفز
        val = self.pop()
        if not val:
            self.jump(jump)

    ## الكتل

    def byte_SETUP_LOOP(self, dest):
        # تسجيل كتلة حلقة ومعرفة مكان الخروج منها
        self.push_block('loop', dest)

    def byte_GET_ITER(self):
        # تحويل قيمة إلى مُكرّر ووضعه في المكدّس
        self.push(iter(self.pop()))

    def byte_FOR_ITER(self, jump):
        # جلب العنصر التالي من المُكرّر، أو القفز عند انتهاء التكرار
        iterobj = self.top()
        try:
            v = next(iterobj)
            self.push(v)
        except StopIteration:
            # عند انتهاء التكرار: إزالة المُكرّر والقفز للخروج
            self.pop()
            self.jump(jump)

    def byte_BREAK_LOOP(self):
        # إشارة إلى رغبة في كسر الحلقة
        return 'break'

    def byte_POP_BLOCK(self):
        # إنهاء أحدث كتلة مسجّلة
        self.pop_block()

    ## الدوال

    def byte_MAKE_FUNCTION(self, argc):
        # إنشاء دالة من كائن الكود + الاسم + القيم الافتراضية
        name = self.pop()
        code = self.pop()
        defaults = self.popn(argc)
        globs = self.frame.f_globals
        fn = Function(name, code, globs, defaults, None, self)
        self.push(fn)

    def byte_CALL_FUNCTION(self, arg):
        # استدعاء دالة بعد تجهيز معاملات الموضع فقط (دون معاملات مسماة هنا)
        lenKw, lenPos = divmod(arg, 256)  # المعاملات المسماة غير مدعومة هنا
        posargs = self.popn(lenPos)

        func = self.pop()
        retval = func(*posargs)  # تنفيذ الدالة فعليًا
        self.push(retval)        # وضع الناتج في المكدّس

    def byte_RETURN_VALUE(self):
        # إنهاء الدالة الحالية وإرجاع قيمة
        self.return_value = self.pop()
        return "return"

تحديد الأنواع الديناميكي Dynamic Typing

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

>>> def mod(a, b):
...    return a % b
>>> dis.dis(mod)
  2           0 LOAD_FAST                0 (a)
              3 LOAD_FAST                1 (b)
              6 BINARY_MODULO
              7 RETURN_VALUE
>>> mod(19, 5)
4

تعطي عملية حساب ‎19 % 5‎ النتيجة 4، ولكن قد نتساءل عمّا يحدث عند استدعائها مع وسطاء مختلفة كما يلي:

>>> mod("by%sde", "teco")
'bytecode'

هذا شيء غريب، ولكنه يشبه ما يحدث في سياق مختلف كما يلي:

>>> print("by%sde" % "teco")
bytecode

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

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

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

سنعرف أن العملية التالية a % b بدون فائدة بنظرة واحدة إليها:

def mod(a,b):
    a % b
    return a %b

لا يمكن لتحليل هذه الشيفرة البرمجية الثابت -الذي يمكن تطبيقه دون تشغيلها- التأكد من أن التعليمة a % b لا تفعل شيئًا، ولكن قد يؤدي استدعاء التابع __mod__ مع % إلى الكتابة في ملف أو التفاعل مع جزء آخر من برنامجنا أو فعل أي شيء آخر ممكن في بايثون، إذ من الصعب تحسين دالة عندما لا نعرف ما تفعله. وضع كل من Russell Power و Alex Rubinsteyn في ورقتهما العلمية التي تدرس مقدار السرعة التي يمكن الوصول إليها لتفسير بايثون ملاحظةً مفادها بأنه: يجب التعامل مع كل تعليمة على أنها INVOKE_ARBITRARY_METHOD مع عدم وجود معلومات عن النوع.

الخلاصة

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

يُنصَح بتفكيك برامجنا الخاصة وتشغيلها باستخدام Byterun، ولكن سنعثر على تعليمات لا تنفذها هذه النسخة القصيرة من Byterun، لذا يمكن العثور على التنفيذ الكامل على Github أو من خلال القراءة الدقيقة لملف ceval.c الخاص بمفسر CPython الحقيقي.

ملاحظة: يعتمد هذا المقال على البايت كود الناتج من إصدار Python 3.5 أو الإصدارات الأقدم، حيث كانت هناك بعض التغييرات على مواصفات البايت كود في الإصدار Python 3.6.

ترجمة -وبتصرّف- للمقال A Python Interpreter Written in Python لصاحبته Allison Kaptur.

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

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

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

قد يحتوي التمرين على أسئلة من نوع:

1. اشرح وظيفة الدالة process_numbers في المثال التالي وما هو الخرج؟
2. ما هي العملية التي يمكن التخلي عنها دون أن يؤثر ذلك في الخرج؟

def process_numbers(numbers):
    unique_numbers = list(set(numbers))
    unique_numbers.sort()
    unique_tuple = tuple(unique_numbers)
    total = sum(unique_tuple)
    average = total / len(unique_tuple) if unique_tuple else 0
    return [num for num in unique_tuple if num > average]

print(process_numbers([7,1,3,4,2,3,5,6,4]))

وتكون الإجابة على النحو الآتي:

• الجواب 1: تقبل الدالة السابقة وسيطًا على شكل قائمة list مكونة من أعداد ثم تختار العناصر الفريدة منها وتوجِد متوسطها الحسابي، ثم تعيد قائمةً تضم الأعداد الفريدة الأكبر تمامًا من المتوسط. وسيكون الخرج [7, 6, 5]
• الجواب 2: عملية تحويل القائمة List إلى قائمة Tuple في السطر الرابع

التمرين الثاني: استخدام مكتبات بايثون مقارنة بالتنفيذ اليدوي لخوارزمية

قد يحتوي التمرين على أسئلة من نوع:

1. ما وظيفة الشيفرة في هذا التمرين؟
2. هل يمكنك تنفيذ نفس الوظيفة باستخدام مكتبات جاهزة؟
3. اكتب شيفرةً تقارن بين زمني تنفيذ الطريقتين السابقتين، ما الذي تلاحظه مع الازدياد الكبير لحجم قائمة البيانات؟

import random

random_data = set(random.sample(range(1, 10000), 1000))

def calculate_median(data):
   data = list(data)
    data.sort()
    n = len(data)
    mid = n // 2
    if n % 2 == 1:
        return data[mid]
    else:
        return (data[mid - 1] + data[mid]) / 2