شرح مفهوم الـ Recursion في بايثون للمبتدئين - التعريف والأمثلة

🌀 فهم الـ Recursion في بايثون: عندما تستدعي الدالة نفسها!

مرحباً بك في عالم البرمجة العودية! تخيل أن لديك صندوقاً بداخله صندوق مماثل تماماً، وهذا الصندوق بداخله صندوق آخر، وهكذا. الـ Recursion يشبه هذا تماماً - إنها تقنية في البرمجة حيث تستدعي الدالة (Function) نفسها أثناء تنفيذها.

🔍 ما هي الـ Recursion (الدوال العودية)؟

ببساطة شديدة، الـ Recursion هي عملية يقوم فيها الحل لمشكلة ما بالاعتماد على حلول لمشكلات أصغر من نفس النوع. الفكرة الأساسية هي تقسيم المشكلة الكبيرة إلى مشكلات أصغر وأبسط، حتى نصل إلى مشكلة صغيرة جداً يسهل حلها. هذا الجزء البسيط يسمى الحالة الأساسية (Base Case).

فكر في الأمر وكأنك تريد عد الأرقام من 5 إلى 1. الطريقة العودية ستكون: "لأعد من 5، أحتاج أولاً إلى العد من 4، ولأعد من 4، أحتاج أولاً إلى العد من 3"... وهكذا حتى أصل إلى 1، وعندها أعرف أن العد انتهى.

⚙️ كيف تعمل الدالة العودية؟ المكونان الرئيسيان

لكي تعمل الدالة العودية بشكل صحيح ولا تتسبب في تكرار لا نهائي (Infinite Loop)، يجب أن تحتوي على مكونين أساسيين:

1. الحالة الأساسية (Base Case): هذه هي الحالة التي توقف عملية الاستدعاء الذاتي. إنها أبسط شكل ممكن للمشكلة، والذي نعرف إجابته مباشرةً دون الحاجة لمزيد من الاستدعاءات. بدون قاعدة أساسية، ستستمر الدالة في استدعاء نفسها إلى الأبد حتى تمتلئ ذاكرة الكمبيوتر!

2. الخطوة العودية (Recursive Step): هذه هي الخطوة التي تقسم فيها المشكلة إلى مشكلة أصغر (أقرب إلى الحالة الأساسية) وتستدعي الدالة نفسها لحلها.

def recursive_function(n):
    # 1. التحقق من الحالة الأساسية (Base Case)
    if n <= 0:
        return "تم الوصول إلى القاعدة!"
    else:
        # 2. الخطوة العودية (Recursive Step)
        # نقوم بعمل ما، ثم نستدعي الدالة نفسها بقيمة أصغر (n-1)
        print(f"القيمة الحالية: {n}")
        return recursive_function(n - 1) # استدعاء ذاتي

# تجربة الدالة
result = recursive_function(3)
print(result)

ماذا يحدث عند التنفيذ؟

1. recursive_function(3) تطبع "القيمة الحالية: 3" ثم تستدعي recursive_function(2).
2. recursive_function(2) تطبع "القيمة الحالية: 2" ثم تستدعي recursive_function(1).
3. recursive_function(1) تطبع "القيمة الحالية: 1" ثم تستدعي recursive_function(0).
4. recursive_function(0) تتحقق من الشرط (0 <= 0 يكون صحيحاً) وتعود بالقيمة "تم الوصول إلى القاعدة!".
5. ترجع هذه القيمة عبر جميع الاستدعاءات السابقة حتى النهاية.

💡 مثال عملي 1: حساب المضروب (Factorial)

المضروب لعدد صحيح غير سالب n (يُكتب n!) هو حاصل ضرب جميع الأعداد الصحيحة من 1 إلى n. على سبيل المثال: 5! = 5 * 4 * 3 * 2 * 1 = 120

لاحظ أننا يمكننا كتابة: 5! = 5 * 4! وهكذا، n! = n * (n-1)!. هذه علاقة عودية واضحة!

def factorial(n):
    # 1. الحالة الأساسية: مضروب 0 و 1 هو 1
    if n == 0 or n == 1:
        return 1
    else:
        # 2. الخطوة العودية: n! = n * (n-1)!
        return n * factorial(n - 1)

# اختبار الدالة
print(factorial(5))  # الناتج: 120
# كيف تم الحساب؟
# factorial(5) = 5 * factorial(4)
# factorial(4) = 4 * factorial(3)
# factorial(3) = 3 * factorial(2)
# factorial(2) = 2 * factorial(1)
# factorial(1) = 1 (الحالة الأساسية)
# ثم ترجع القيم للأعلى: 2*1=2, ثم 3*2=6, ثم 4*6=24, ثم 5*24=120

💡 مثال عملي 2: متتالية فيبوناتشي (Fibonacci Sequence)

متتالية فيبوناتشي هي سلسلة أرقام حيث كل رقم هو مجموع الرقمين السابقين له. تبدأ بـ 0 و 1. 0, 1, 1, 2, 3, 5, 8, 13, 21, ...

العلاقة هنا هي: fib(n) = fib(n-1) + fib(n-2)

def fibonacci(n):
    # 1. الحالة الأساسية
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        # 2. الخطوة العودية
        return fibonacci(n - 1) + fibonacci(n - 2)

# اختبار الدالة
print(fibonacci(6))  # الناتج: 8
# لأن المتتالية: 0, 1, 1, 2, 3, 5, 8

⚠️ نقاط مهمة يجب تذكرها عن الـ Recursion

• الحالة الأساسية هي مفتاح النجاح: بدونها، سيتوقف البرنامج بخطأ "تجاوز العمق الأقصى للاستدعاءات (Maximum Recursion Depth Exceeded)".
• ليست الحل الأمثل دائماً: في بعض الأحيان، تكون الحلول التكرارية (باستخدام الحلقات مثل for أو while) أكثر كفاءة من حيث الذاكرة والسرعة، خاصة إذا كانت الدالة تستدعي نفسها مرات عديدة جداً (كما في مثال فيبوناتشي).
• تجعل الكود أنيقاً: للعديد من المشكلات (مثل التعامل مع الهياكل الشجرية)، يكون الحل العودي أكثر وضوحاً وأسهل في القراءة والكتابة من الحل التكراري.