جملة التخطي continue في بايثون (Continue Statement)

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

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

في هذا الدرس المفصل، ستتعلم كل ما تحتاجه عن جملة continue: متى تستخدمها، كيف تختلف عن break، وكيف توظفها في سيناريوهات عملية مثل تصفية البيانات ومعالجة الاستثناءات.

1. مفهوم جملة continue وآلية عملها

جملة continue هي كلمة مفتاحية محجوزة في بايثون تُستخدم حصرياً داخل حلقات التكرار (for و while). وظيفتها هي تخطي ما تبقى من الدورة الحالية والانتقال مباشرة للدورة التالية.

كيف تعمل continue؟

  1. التوقف عن التنفيذ: يتوقف تنفيذ أي كود متبقي في الدورة الحالية
  2. العودة للشرط: في حلقة while، يعود لفحص الشرط
  3. الانتقال للعنصر التالي: في حلقة for، ينتقل للعنصر التالي
  4. استمرار الحلقة: الحلقة تستمر بشكل طبيعي، فقط الدورة الحالية تُتخطى
basic_continue_concept.py
# مثال توضيحي: طباعة الأرقام مع تخطي رقم معين
print("طباعة الأرقام من 1 إلى 7 مع تخطي الرقم 4:")
print("-" * 40)

for i in range(1, 8):
    if i == 4:
        print(f"   [{i}] <- تم تخطي هذا الرقم")
        continue  # تخطي باقي الكود والانتقال للرقم التالي
    
    print(f"   الرقم: {i}")

print("-" * 40)
print("انتهى البرنامج")
النتيجة
طباعة الأرقام من 1 إلى 7 مع تخطي الرقم 4: ---------------------------------------- الرقم: 1 الرقم: 2 الرقم: 3 [4] <- تم تخطي هذا الرقم الرقم: 5 الرقم: 6 الرقم: 7 ---------------------------------------- انتهى البرنامج
ملاحظة مهمة: لاحظ أن الحلقة استمرت حتى النهاية. فقط الرقم 4 تم تخطيه، لكن الأرقام 5 و 6 و 7 طُبعت بشكل طبيعي. هذا الفرق الجوهري بين continue و break.

2. الفرق الجوهري بين break و continue

من أكثر الأمور التي تُربك المبتدئين هو الخلط بين break و continue. دعنا نوضح الفرق بشكل قاطع.

الخاصية break continue
التأثير يوقف الحلقة بالكامل يتخطى الدورة الحالية فقط
الدورات التالية لا تُنفذ أبداً تُنفذ بشكل طبيعي
الخروج من الحلقة نعم، فوراً لا، تستمر الحلقة
كتلة else لا تُنفذ تُنفذ بشكل طبيعي
الاستخدام الشائع البحث والعثور التصفية والفلترة
break_vs_continue.py
# مقارنة عملية بين break و continue
numbers = [1, 2, 3, 4, 5, 6, 7]

print("=== استخدام break (توقف عند 4) ===")
for num in numbers:
    if num == 4:
        print("   [break] توقف!")
        break
    print(f"   الرقم: {num}")

print("\n=== استخدام continue (تخطي 4 فقط) ===")
for num in numbers:
    if num == 4:
        print("   [continue] تخطي!")
        continue
    print(f"   الرقم: {num}")
النتيجة
=== استخدام break (توقف عند 4) === الرقم: 1 الرقم: 2 الرقم: 3 [break] توقف! === استخدام continue (تخطي 4 فقط) === الرقم: 1 الرقم: 2 الرقم: 3 [continue] تخطي! الرقم: 5 الرقم: 6 الرقم: 7

3. استخدام continue مع حلقة for

مع حلقة for، تُستخدم continue بشكل أساسي لتصفية العناصر غير المرغوبة أثناء المعالجة.

مثال: تصفية الأرقام الزوجية

filter_even_numbers.py
# طباعة الأرقام الفردية فقط من 1 إلى 10
print("الأرقام الفردية من 1 إلى 10:")
print("-" * 30)

for num in range(1, 11):
    # تخطي الأرقام الزوجية
    if num % 2 == 0:
        continue
    
    print(f"   {num} (فردي)")

print("-" * 30)
النتيجة
الأرقام الفردية من 1 إلى 10: ------------------------------ 1 (فردي) 3 (فردي) 5 (فردي) 7 (فردي) 9 (فردي) ------------------------------

مثال: تصفية البيانات الفارغة

filter_empty_data.py
# معالجة قائمة مع تجاهل العناصر الفارغة
user_inputs = ["Ahmed", "", "Sara", "   ", "Omar", None, "Fatima", ""]

print("معالجة أسماء المستخدمين:")
print("-" * 35)

valid_count = 0
for name in user_inputs:
    # تخطي القيم الفارغة أو None
    if name is None:
        print("   [تخطي] قيمة فارغة (None)")
        continue
    
    # تخطي النصوص الفارغة أو المسافات فقط
    if name.strip() == "":
        print("   [تخطي] نص فارغ")
        continue
    
    # معالجة البيانات الصالحة
    valid_count += 1
    print(f"   [{valid_count}] {name.strip()}")

print("-" * 35)
print(f"تمت معالجة {valid_count} اسم صالح من أصل {len(user_inputs)}")
النتيجة
معالجة أسماء المستخدمين: ----------------------------------- [1] Ahmed [تخطي] نص فارغ [2] Sara [تخطي] نص فارغ [3] Omar [تخطي] قيمة فارغة (None) [4] Fatima [تخطي] نص فارغ ----------------------------------- تمت معالجة 4 اسم صالح من أصل 8

4. استخدام continue مع حلقة while

مع حلقة while، يجب الانتباه لنقطة مهمة جداً: تأكد من تحديث متغير الشرط قبل continue، وإلا قد تقع في حلقة لانهائية.

تحذير مهم: إذا كان تحديث المتغير يأتي بعد continue، فلن يتم تنفيذه وستعلق في حلقة لانهائية.
continue_while_correct.py
# الطريقة الصحيحة: تحديث المتغير قبل continue
print("طباعة الأرقام من 1 إلى 10 مع تخطي مضاعفات 3:")
print("-" * 45)

i = 0
while i < 10:
    i += 1  # تحديث المتغير أولاً (مهم جداً!)
    
    if i % 3 == 0:
        print(f"   [{i}] <- تخطي (مضاعف للرقم 3)")
        continue
    
    print(f"   الرقم: {i}")

print("-" * 45)
النتيجة
طباعة الأرقام من 1 إلى 10 مع تخطي مضاعفات 3: --------------------------------------------- الرقم: 1 الرقم: 2 [3] <- تخطي (مضاعف للرقم 3) الرقم: 4 الرقم: 5 [6] <- تخطي (مضاعف للرقم 3) الرقم: 7 الرقم: 8 [9] <- تخطي (مضاعف للرقم 3) الرقم: 10 ---------------------------------------------

مثال على الخطأ الشائع

continue_while_wrong.py (لا تشغل هذا الكود)
# الطريقة الخاطئة: حلقة لانهائية!
i = 0
while i < 10:
    if i == 3:
        continue  # i تظل 3 للأبد!
    
    print(i)
    i += 1  # هذا السطر لن يُنفذ عندما i = 3

5. continue والحلقات المتداخلة

مثل break، جملة continue تؤثر فقط على الحلقة الأقرب إليها (الحلقة التي تحتويها مباشرة). الحلقة الخارجية تستمر بشكل طبيعي.

nested_continue.py
# تخطي أزواج معينة في حلقات متداخلة
print("جدول الضرب مع تخطي عندما يكون الناتج زوجياً:")
print("=" * 45)

for i in range(1, 4):
    print(f"\nجدول العدد {i}:")
    
    for j in range(1, 6):
        result = i * j
        
        if result % 2 == 0:
            # تخطي النتائج الزوجية
            continue  # يؤثر على الحلقة الداخلية فقط
        
        print(f"   {i} x {j} = {result}")

print("\n" + "=" * 45)
النتيجة
جدول الضرب مع تخطي عندما يكون الناتج زوجياً: ============================================= جدول العدد 1: 1 x 1 = 1 1 x 3 = 3 1 x 5 = 5 جدول العدد 2: جدول العدد 3: 3 x 1 = 3 3 x 3 = 9 3 x 5 = 15 =============================================

6. تطبيقات عملية لجملة continue

التطبيق الأول: نظام معالجة الطلبات

order_processing.py
# نظام معالجة الطلبات مع تخطي الطلبات غير الصالحة
orders = [
    {"id": 1, "product": "Laptop", "quantity": 2, "status": "confirmed"},
    {"id": 2, "product": "Phone", "quantity": 0, "status": "confirmed"},
    {"id": 3, "product": "Tablet", "quantity": 1, "status": "cancelled"},
    {"id": 4, "product": "Watch", "quantity": 3, "status": "confirmed"},
    {"id": 5, "product": "", "quantity": 1, "status": "confirmed"},
]

print("=" * 50)
print("           نظام معالجة الطلبات")
print("=" * 50)

processed = 0
skipped = 0

for order in orders:
    order_id = order["id"]
    
    # تخطي الطلبات الملغاة
    if order["status"] == "cancelled":
        print(f"[{order_id}] تخطي: الطلب ملغى")
        skipped += 1
        continue
    
    # تخطي الطلبات بكمية صفر
    if order["quantity"] <= 0:
        print(f"[{order_id}] تخطي: الكمية غير صالحة")
        skipped += 1
        continue
    
    # تخطي الطلبات بدون اسم منتج
    if not order["product"]:
        print(f"[{order_id}] تخطي: المنتج غير محدد")
        skipped += 1
        continue
    
    # معالجة الطلب الصالح
    processed += 1
    print(f"[{order_id}] معالجة: {order['quantity']} x {order['product']}")

print("-" * 50)
print(f"تمت المعالجة: {processed} | تم التخطي: {skipped}")
النتيجة
================================================== نظام معالجة الطلبات ================================================== [1] معالجة: 2 x Laptop [2] تخطي: الكمية غير صالحة [3] تخطي: الطلب ملغى [4] معالجة: 3 x Watch [5] تخطي: المنتج غير محدد -------------------------------------------------- تمت المعالجة: 2 | تم التخطي: 3

التطبيق الثاني: حاسبة تفاعلية

interactive_calculator.py
# حاسبة تفاعلية مع معالجة الأخطاء
print("=" * 40)
print("        الحاسبة التفاعلية")
print("=" * 40)
print("أدخل أرقاماً للجمع (أو 'q' للخروج)")
print("-" * 40)

total = 0
count = 0

while True:
    user_input = input("أدخل رقماً: ")
    
    # الخروج من البرنامج
    if user_input.lower() == 'q':
        break
    
    # محاولة تحويل الإدخال لرقم
    try:
        number = float(user_input)
    except ValueError:
        print("   [خطأ] إدخال غير صالح، حاول مجدداً")
        continue  # تخطي والمحاولة مرة أخرى
    
    # تخطي الأرقام السالبة (اختياري)
    if number < 0:
        print("   [تحذير] تم تجاهل الرقم السالب")
        continue
    
    # إضافة الرقم للمجموع
    total += number
    count += 1
    print(f"   المجموع الحالي: {total}")

print("-" * 40)
if count > 0:
    print(f"المجموع النهائي: {total}")
    print(f"عدد الأرقام: {count}")
    print(f"المتوسط: {total / count:.2f}")

7. الجمع بين break و continue

يمكن استخدام break و continue معاً في نفس الحلقة لتحقيق منطق معقد.

break_and_continue.py
# البحث عن أول رقم أولي زوجي أكبر من 10
# (تخطي غير الأولية، توقف عند العثور)

print("البحث عن أرقام أولية بين 10 و 50:")
print("-" * 40)

found_count = 0
max_to_find = 5

for num in range(10, 51):
    # تخطي الأرقام الزوجية (ما عدا 2)
    if num > 2 and num % 2 == 0:
        continue
    
    # التحقق من أن الرقم أولي
    is_prime = True
    for i in range(2, int(num ** 0.5) + 1):
        if num % i == 0:
            is_prime = False
            break
    
    if not is_prime:
        continue  # تخطي غير الأولية
    
    # وجدنا رقماً أولياً
    found_count += 1
    print(f"   [{found_count}] الرقم {num} أولي")
    
    # التوقف بعد العثور على 5 أرقام
    if found_count >= max_to_find:
        print(f"\n   [توقف] تم العثور على {max_to_find} أرقام")
        break

print("-" * 40)
النتيجة
البحث عن أرقام أولية بين 10 و 50: ---------------------------------------- [1] الرقم 11 أولي [2] الرقم 13 أولي [3] الرقم 17 أولي [4] الرقم 19 أولي [5] الرقم 23 أولي [توقف] تم العثور على 5 أرقام ----------------------------------------

8. أفضل الممارسات والنصائح

متى تستخدم continue
  • لتصفية البيانات غير المرغوبة
  • لتخطي الحالات الاستثنائية
  • لتجنب التداخل العميق في الشروط
  • لمعالجة الأخطاء مع الاستمرار
  • لتخطي العناصر الفارغة أو غير الصالحة
تحذيرات
  • تأكد من تحديث المتغير قبل continue في while
  • لا تفرط في استخدامها (تصعب قراءة الكود)
  • تذكر أنها تؤثر على الحلقة الأقرب فقط
  • لا تستخدمها خارج الحلقات
  • فكر في بدائل مثل الشروط المعكوسة
ملخص الدرس
  • جملة continue تتخطى الدورة الحالية وتنتقل للدورة التالية
  • تختلف عن break التي توقف الحلقة بالكامل
  • مفيدة جداً في تصفية البيانات ومعالجة الاستثناءات
  • مع while، تأكد من تحديث المتغير قبل continue
  • تؤثر على الحلقة الأقرب فقط في حالة الحلقات المتداخلة

المرحلة التالية: بعد إتقان الحلقات والتحكم فيها، حان وقت تعلم الدوال لتنظيم الكود وإعادة استخدامه.

الخطوة التالية

تعلم كيفية إنشاء الدوال لتنظيم الكود وإعادة استخدامه

الدرس التالي: الدوال في بايثون (Functions)
المحرر الذكي

اكتب الكود وشاهد النتيجة فوراً

جرب الآن مجاناً
قناة ديف عربي

تابع أحدث الدروس والتحديثات مباشرة على واتساب

انضم الآن