الانتقال إلى المحتوى
المواد
  • 1 بدء الاستخدام
    1.1

    أول برنامج لك

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

    دالة print() تعرض النص على الشاشة. هذا يسمى الإخراج. النص داخل علامات الاقتباس هو نصي (سلسلة)

    print("Hello, world!")
    print("I am learning Python")
    
    • كل print() يبدأ سطرًا جديدًا.
    • يمكن أن تكون علامات الاقتباس "double" أو 'single' — كلاهما يُنتج نصًا.
    • لا يقوم البرنامج بأي شيء حتى تقوم بتشغيله.
    الكود المصدري يمر عبر المفسر لإنتاج إخراج
    الكود المصدري يمر عبر المفسر لإنتاج إخراج
    1.2

    التعليقات ونمط الكود

    التعليق يبدأ بـ #. يتجاهل بايثون كل ما بعد # في ذلك السطر. التعليقات تشرح كودك للناس؛ وهي لا تغير ما يفعله الكود.

    # This line is a note for humans
    print("Hi")        # you can also comment at the end of a line
    

    النمط الجيد يجعل الكود سهل القراءة:

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

    الإدخال، المعالجة، الإخراج

    تتبع العديد من البرامج خطة بسيطة: إدخال → معالجة → إخراج. تحصل على بعض البيانات، تقوم بشيء ما بها، ثم تعرض النتيجة.

    دالة input() تقرأ النص الذي يكتبه المستخدم. تُرجع دائمًا نصًا (string).

    name = input("What is your name? ")
    print("Hello, " + name)
    
    • input() ينتظر المستخدم ليقوم بالكتابة والضغط على Enter.
    • احفظ النص المكتوب في متغير لتتمكن من استخدامه لاحقًا.
    • نظرًا لأن input() تُرجع نصًا، قم بتحويلها باستخدام int(...) أولًا إذا كنت بحاجة إلى رقم.

    أخطاء شائعة

    • نسيان علامات التنصيص: print(Hello) تبحث عن متغير باسم Hello وتُثير NameError. النص يحتاج إلى تنصيص: print("Hello").
    • مسافة زائدة في بداية السطر: بايثون يقرأ المسافة البادئة كهيكل، لذا تُثير IndentationError.
    • افتراض أن input() تُرجع رقمًا. إنها تُرجع دائمًا نصًا، لذا غلفها بـ int(...) قبل إجراء أي عمليات حسابية.
  • 2 المتغيرات، الأنواع والعمليات
    2.1

    المتغيرات والتعيين

    المتغير هو اسم للقيمة. تنشئه باستخدام =، والذي يُسمى التعيين. الاسم يكون على اليسار؛ القيمة تكون على اليمين.

    age = 17
    name = "Mei"
    price = 9.99
    print(age, name, price)
    

    الآن age يحتوي على 17. استخدم الاسم أينما تحتاج القيمة، وغيّرها لاحقًا:

    age = 17
    age = age + 1   # age is now 18
    print(age)
    
    المتغير هو اسم مرتبط بقيمة مخزنة
    يشير كل اسم متغير إلى قيمة في الذاكرة
    • علامة = لا تعني "يساوي". بل تعني "احفظ الجانب الأيمن تحت الاسم الأيسر".
    • لاختبار ما إذا كانت قيمتان متساويتين، استخدم == (أنظر أدناه).
    2.2

    الأرقام: int & float

    يحتوي بايثون على نوعين رئيسيين للأرقام. العدد الصحيح (int) هو عدد صحيح مثل 17. الكسر العشري (float) يحتوي على نقطة عشرية مثل 9.99.

    تعمل هذه العمليات الحسابية على الأرقام:

    العملية المعنى المثال النتيجة
    + إضافة 3 + 2 5
    - طرح 3 - 2 1
    * ضرب 3 * 2 6
    / قسمة (دائماً كسر عشري) 7 / 2 3.5
    // قسمة صحيحة 7 // 2 3
    % باقي القسمة (modulo) 7 % 2 1
    ** أس (قوة) 2 ** 3 8
    • / تُرجع دائمًا كسرًا عشريًا، لذا 4 / 2 هي 2.0.
    • // و% يعملان معًا: 17 // 5 هي 3، و17 % 5 هي 2.
    2.3

    التعبيرات وتحويل النوع

    التعبير هو أي شيء له قيمة، مثل 3 + 4 * 2. يستخدم بايثون ترتيب العمليات الحسابية الطبيعي (* و/ قبل + و-)؛ أضف أقواس لجعل الترتيب واضحًا.

    input() تُرجع نصًا، لذا حولها قبل إجراء العمليات الحسابية. تغيير قيمة من نوع إلى آخر هو تحويل النوع (type conversion):

    age = int("17")        # text "17" -> number 17
    price = float("9.99")  # text -> 9.99
    label = str(17)        # number -> text "17"
    print(age, price, label)
    
    • int("abc") تفشل، لذا حوّل فقط النصوص التي تشبه الأرقام.
    • خلط الأنواع يفشل أيضًا: "age: " + 17 هو خطأ؛ اكتب "age: " + str(17).
    2.4

    المنطق والمقارنة

    القيمة المنطقية (Boolean) هي واحدة من قيمتين فقط: True أو False. المقارنة تُرجع قيمة منطقية.

    العملية المعنى
    == يساوي
    != لا يساوي
    < > أصغر من / أكبر من
    <= >= أصغر من أو يساوي / أكبر من أو يساوي
    print(7 > 2)        # True
    print(3 == 3.0)     # True
    age = 20
    print(age >= 18)    # True
    

    اجمع المقارنات باستخدام and، or، not:

    age = 20
    print(age >= 13 and age <= 19)   # True only for a teenager
    

    أخطاء شائعة

    • / تُرجع دائمًا كسرًا عشريًا، حتى لو كان 4 / 2 هو 2.0. استخدم // عندما تريد عددًا صحيحًا.
    • استخدام = بدلاً من ==: = يعيّن قيمة، بينما == يختبر ما إذا كانت قيمتان متساويتين.
    • دمج نص ورقم: "age: " + 5 تُثير TypeError. حوّل أولاً باستخدام str(5).
    • الكسور العشرية ليست دقيقة تمامًا، لذا 0.1 + 0.2 ليست بالضبط 0.3 — تجنب == على نتائج الكسور العشرية.
  • 3 النصوص
    3.1

    الفهرسة

    النص هو نص داخل علامات تنصيص. لكل حرف موقع، يُسمى فهرسه. الفهرس الأول هو 0، وليس 1.

    اقرأ حرفًا واحدًا باستخدام الأقواس المربعة:

    word = "Python"
    print(word[0])    # P  (the first character)
    print(word[2])    # t
    print(len(word))  # 6  (how many characters)
    
    • يبدأ العد من 0، لذا الفهرس الأخير هو len(word) - 1.
    • الفهرس السالب يعدّ للخلف من النهاية: word[-1] هو الحرف الأخير.
    word = "Python"
    print(word[-1])   # n
    print(word[-2])   # o
    
    • الفهرس الذي يكون كبيرًا جدًا يسبب خطأ (وهو IndexError).
    s[start:stop] هي نافذة مفتوحة جزئيًا من الأحرف
    s[start:stop] هي نافذة مفتوحة جزئيًا من الأحرف
    3.2

    التقطيع (Slicing)

    الشرطة تأخذ جزءًا من النص. اكتب word[start:end]. تحافظ الشريحة على start but تتوقف قبل end.

    word = "Python"
    print(word[0:3])   # Pyt   (positions 0, 1, 2)
    print(word[2:5])   # tho
    
    • تخطِّ start للبدء من 0؛ تخطِّ end للذهاب إلى النهاية.
    word = "Python"
    print(word[:3])    # Pyt
    print(word[3:])    # hon
    
    • الرقم الثالث هو الخطوة. word[::-1] يعكس النص.
    print("Python"[::-1])   # nohtyP
    
    3.3

    دوال النص وطوله

    الدالة (method) هي دالة تتبع قيمة. استدعيها بنقطة:

    name = "mei chen"
    print(name.upper())     # MEI CHEN
    print(name.title())     # Mei Chen
    print(len(name))        # 8
    

    النصوص غير قابلة للتغيير: الدالة تُرجع نصًا جديدًا ولا تغير النص الأصلي أبدًا.

    name = "mei"
    print(name.upper())     # MEI  (the returned value)
    print(name)             # mei  (the original is unchanged)
    

    دوال شائعة (كل منها يُرجع قيمة جديدة):

    الدالة المعنى المثال النتيجة
    .upper() / .lower() تغيير الحالة "Hi".lower() hi
    .strip() إزالة المسافات الهامشية " hi ".strip() hi
    .replace(a, b) تبديل النص "cat".replace("c", "b") bat
    .split(sep) تفكيك إلى قائمة "a,b".split(",") ['a', 'b']

    اجمع النصوص باستخدام +. هذا يسمى الوصل (concatenation):

    first = "Mei"
    last = "Chen"
    print(first + " " + last)   # Mei Chen
    
    3.4

    n-strings

    n-string يبني نصًا من القيم. ضع f قبل علامة التنصيص، ثم اكتب {...} حول قيمة.

    name = "Mei"
    age = 17
    print(f"{name} is {age} years old")   # Mei is 17 years old
    
    • يمكن وضع أي تعبير داخل الأقواس.
    • {value:.2f} يُقرب إلى 2 منازل عشرية.
    price = 9.5
    print(f"Two cost {price * 2}")        # Two cost 19.0
    print(f"Pi is about {3.14159:.2f}")   # Pi is about 3.14
    

    أخطاء شائعة

    • لا يمكن تغيير النصوص في مكانها: s[0] = "x" تُثير خطأ. قم بإنشاء نص جديد بدلاً من ذلك.
    • تبدأ الفهرسة من 0؛ الحرف الأخير هو s[-1]، وs[len(s)] خارج النطاق.
    • تقطيع s[a:b] يتضمن a ويتوقف قبل b.
    • دوال النص تُرجع نصًا جديداً: s.upper() لن يفعل شيئًا إلا إذا قمت بتخزين النتيجة.
  • 4 الاختيار
    4.1

    if / elif / else

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

    score = 72
    if score >= 60:
        print("pass")
    # pass
    

    أضف elif (إلا إذا) لحالات أكثر وأضف else لـ "أي حالة أخرى". تقوم Python بتنفيذ الفرع الصحيح الأول فقط، ثم تتخطى الباقي.

    score = 72
    if score >= 80:
        print("A")
    elif score >= 60:
        print("B")
    else:
        print("fail")
    # B
    
    • قارن القيم باستخدام == (يساوي)، != (لا يساوي)، <، >، <=، >=.
    • تعطي المقارنة قيمة منطقية — إما True أو False.
    if / elif / else: يتم تنفيذ فرع واحد فقط
    if / elif / else: يتم تنفيذ فرع واحد فقط
    4.2

    دمج الشروط

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

    age = 16
    has_ticket = True
    if age >= 18 and has_ticket:
        print("entry allowed")
    else:
        print("entry refused")
    # entry refused
    
    • استخدم الأقواس لتوضيح الترتيب: (a or b) and c.
    temp = 30
    if temp > 25 and not temp > 35:
        print("warm but ok")
    # warm but ok
    

    أخطاء شائعة

    • اكتب elif، لا else if.
    • كل سطر if / elif / else ينتهي بفاصلة منقوطة :، ويجب تنسيق جسمه بالمسافة البادئة.
    • if x = 5: خطأ — استخدم == للمقارنة.
    • لا يأخذ else شرطًا؛ بل if وelif فقط.
  • 5 التكرار
    5.1

    حلقات for ونطاق range

    الحلقة تكرر الكود. حلقة for تكرر مرة واحدة لكل عنصر في تسلسل. تُعطي range(n) الأرقام من 0 إلى n - 1.

    for i in range(5):
        print(i)
    # 0, then 1, 2, 3, 4 (each on its own line)
    
    • يذهب range(a, b) من a إلى (ولكن دون تضمين) b.
    • يضيف range(a, b, step) خطوة في كل مرة.
    for n in range(2, 11, 2):
        print(n)        # 2 4 6 8 10
    
    for i in range(n): يعمل الجسم مع i = 0 … n-1
    for i in range(n): يعمل الجسم مع i = 0 … n-1
    5.2

    نمط المجمع

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

    total = 0
    for n in range(1, 6):
        total = total + n
    print(total)        # 15
    
    • نفس الفكرة يحسب عدد العناصر التي تطابق اختبارًا معينًا.
    count = 0
    for letter in "banana":
        if letter == "a":
            count = count + 1
    print(count)        # 3
    
    5.3

    حلقات while

    تكرّر حلقة while طالما يبقى الشرط صحيحًا. غيّر شيئًا بداخلها، وإلا فلن تتوقف أبدًا — حلقة لا نهائية.

    n = 1
    while n <= 3:
        print(n)
        n = n + 1
    # 1 2 3
    
    • يُخرجك break من الحلقة فورًا.
    total = 0
    while True:
        total = total + 10
        if total >= 30:
            break
    print(total)        # 30
    
    5.4

    الحلقات المتداخلة

    الحلقة داخل حلقة أخرى هي حلقة متداخلة. تعمل الحلقة الداخلية بالكامل في كل دورة للحلقة الخارجية.

    for row in range(3):
        line = ""
        for col in range(3):
            line = line + "*"
        print(line)
    # ***
    # ***
    # ***
    

    أخطاء شائعة

    • يذهب range(n) من 0 إلى n - 1، وليس من 1 إلى n — الخطأ الكلاسيكي بإزاحة بمقدار واحد.
    • تغيير قائمة أثناء المرور عليها يتجاوز بعض العناصر؛ مرر على نسخة إذا كان عليك إزالة أشياء.
    • نسيان تغيير متغير الحلقة في while يجعلها تعمل إلى ما لا نهاية.
    • المسافة البادئة تحدد ما هو داخل الحلقة؛ السطر الخاطئ المسافة البادئة يعمل مرة واحدة فقط، بعد الحلقة.
  • 6 القوائم وقوائم 2-D
    6.1

    القوائم

    تحفظ القائمة قيمًا عديدة بالترتيب، داخل []. لكل عنصر فهرس (من 0).

    scores = [88, 71, 95]
    print(scores[0])      # 88
    print(len(scores))    # 3
    scores.append(60)     # add to the end
    print(scores)         # [88, 71, 95, 60]
    
    • غيّر عنصرًا بفهرسه: scores[1] = 100.
    • يمكن للقائمة أن تكبر وتصغر؛ ولا يمكن للنص ذلك.

    أدوات القوائم اليومية:

    الأداة تفعل
    a.append(x) تضيف x في النهاية
    a.insert(i, x) يُدخل x عند الموضع i
    a.remove(x) يزيل أول x
    a.pop() / a.pop(i) تزيل وتُرجع آخر عنصر / العنصر i
    a.sort() ترتب القائمة محليًا
    sorted(a) تُرجع قائمة مُرتبة جديدة
    x in a هل x موجود في القائمة؟
    len(a)، sum(a)، max(a)، min(a) الحجم والحساب السريع
    فهارس القائمة تبدأ من 0
    فهارس القائمة تبدأ من 0
    6.2

    المرور على قائمة

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

    scores = [88, 71, 95]
    total = 0
    for s in scores:
        total = total + s
    print(total)          # 254
    
    • استخدم enumerate عندما تحتاج أيضًا إلى الفهرس.
    for i, name in enumerate(["a", "b"]):
        print(i, name)    # 0 a  /  1 b
    
    6.3

    قوائم متعددة الأبعاد 2 (شبكات)

    القائمة متعددة الأبعاد 2 هي قائمة من القوائم — شبكة من الصفوف والأعمدة. استخدم مؤشرين: grid[row][col].

    grid = [[1, 2, 3],
            [4, 5, 6]]
    print(grid[0][2])     # 3
    print(grid[1][0])     # 4
    
    • حلقة متداخلة تزور كل خلية.
    grid = [[1, 2], [3, 4]]
    for row in grid:
        for value in row:
            print(value, end=" ")
    print()               # 1 2 3 4
    
    6.4

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

    استيعاب القائمة يبني قائمة جديدة في سطر واحد: [expression for item in sequence].

    squares = [x * x for x in range(5)]
    print(squares)        # [0, 1, 4, 9, 16]
    
    • أضف if للاحتفاظ ببعض العناصر فقط.
    evens = [n for n in range(10) if n % 2 == 0]
    print(evens)          # [0, 2, 4, 6, 8]
    
    6.5

    المجموعات الثابتة والمجموعات

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

    point = (3, 4)
    x, y = point            # unpacking
    print(x, y)             # 3 4
    

    الدالة التي تحتاج إلى إرجاع نتيجتين تُرجع مجموعة ثابتة:

    def min_max(nums):
        return min(nums), max(nums)
    
    lo, hi = min_max([5, 2, 9])
    print(lo, hi)           # 2 9
    

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

    votes = ["red", "blue", "red", "green", "red"]
    colours = set(votes)
    print(len(colours))         # 3  (duplicates removed)
    print("blue" in colours)    # True
    

    أخطاء شائعة

    • b = a يشارك قائمة واحدة. a.copy() أو a[:] تنشئ قائمة خارجية جديدة، لكن العناصر الداخلية القابلة للتعديل تظل مشتركة (نسخة سطحية).
    • العنصر الأخير هو a[-1]؛ a[len(a)] خارج النطاق.
    • يضيف append عنصرًا واحدًا؛ استخدم extend أو + لضم قائمة أخرى.
    • بناء شبكة باستخدام [[0]*3]*3 يجعل ثلاث نسخ من نفس الصف. قم بإنشاء الصفوف داخل حلقة بدلاً من ذلك.
    • العنصر الأحادي يحتاج فاصلة: (5,)، لا (5).
    • المجموعة ليس لها ترتيب ولا تكرارات، لذا لا يمكنك استخدام الفهرس بها مع s[0].
  • 7 المفردات (Dictionaries)
    7.1

    القواميس

    التحفظ القاموس (dict) أزواج مفتاح → قيمة. تبحث عن قيمة بواسطة مفتاحها، وليس بفهرس رقمي.

    student = {"name": "Mei", "score": 88}
    print(student["name"])     # Mei
    print(student["score"])    # 88
    

    الإضافة والتحديث

    أعِني لمفتاح لإضافته، أو لتغيير موجود.

    student = {"name": "Mei"}
    student["score"] = 88      # add a new key
    student["score"] = 90      # update the value
    print(student)             # {'name': 'Mei', 'score': 90}
    

    التحقق والتكرار

    استخدم in لاختبار وجود مفتاح. كرر فوق المفاتيح، أو فوق .items() للحصول على المفتاح والقيمة معًا.

    student = {"name": "Mei", "score": 90}
    print("score" in student)  # True
    for key, value in student.items():
        print(key, "=", value)
    # name = Mei
    # score = 90
    
    • يُرجع .get(key, default) افتراضيًا عند عدم وجود المفتاح — بدون خطأ.
    student = {"name": "Mei"}
    print(student.get("age", 0))   # 0
    

    النمط الكلاسيكي للامتحان — احسب كم مرة يظهر كل قيمة:

    word = "banana"
    counts = {}
    for letter in word:
        counts[letter] = counts.get(letter, 0) + 1
    print(counts)   # {'b': 1, 'a': 3, 'n': 2}
    
    • يُوفر .get(letter, 0) 0 عند ظهور المفتاح لأول مرة، لذا لا يحدث KeyError.

    أخطاء شائعة

    • قراءة مفتاح مفقود باستخدام d[key] ترفع KeyError؛ استخدم d.get(key) أو اختبر if key in d أولاً.
    • إعادة تعيين d[key] تستبدل القيمة القديمة — المفاتيح فريدة.
    • يجب أن تكون المفاتيح غير قابلة للتغيير، مثل النص أو الرقم — لا يمكن للقائمة أن تكون مفتاحًا.
    يُربط القاموس كل مفتاح بقيمة واحدة
    يُربط القاموس كل مفتاح بقيمة واحدة
  • 8 الدوال والتجريد
    8.1

    تعريف واستدعاء الدوال

    الدالة هي كتلة كود مسماة يمكنك إعادة استخدامها. عرّفها باستخدام def، ثم استدعها بالاسم.

    def greet():
        print("Hello!")
    
    greet()        # Hello!
    greet()        # Hello!
    
    • يعمل الكود بداخلها فقط عندما تستدعي الدالة.
    def يُعرّف؛ call يُنفذ؛ return يُرجع قيمة
    def يُعرّف؛ call يشغّل؛ return يرسل قيمة
    8.2

    إرجاع القيم

    يمكن للدالة إرجاع قيمة مع return. بعد ذلك، تمثل الدالة تلك القيمة.

    def square(n):
        return n * n
    
    print(square(5))          # 25
    print(square(3) + 1)      # 10
    
    • يُنهك return الدالة فوراً. أي دالة بدون return تُرجع None.
    8.3

    المعاملات، الحُجج والنطاق

    المعامل هو الاسم في def. والحجة هي القيمة التي تمررها.

    def power(base, exp):         # base, exp are parameters
        return base ** exp
    
    print(power(2, 3))            # 8  (2 and 3 are arguments)
    

    المتغير الذي يتم إنشاؤه داخل دالة يكون محلياً — فهو موجود هناك فقط. هذه المنطقة هي نطاقه.

    def f():
        x = 10            # local to f
        return x
    
    print(f())            # 10
    # print(x) here would be an error: x is not defined outside f
    

    يمكن للمعامل أن يحتوي على قيمة افتراضية، تُستخدم عندما يترك المُدعيها:

    def greet(name, greeting="Hello"):
        return greeting + ", " + name
    
    print(greet("Mei"))              # Hello, Mei
    print(greet("Sam", "Welcome"))   # Welcome, Sam
    
    8.4

    التجريد الإجرائي

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

    def area_of_rectangle(w, h):
        return w * h
    
    print(area_of_rectangle(4, 5))   # 20
    
    • الدالة الجيدة تقوم بوظيفة واحدة، لها اسم واضح، وتتجنب تكرار الكود.
    8.5

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

    الوحدة هي ملف يحتوي على دوال جاهزة. استورد إحداها باستخدام import.

    import random
    random.seed(0)               # makes the result repeatable
    print(random.randint(1, 6))  # a dice roll
    
    import math
    print(math.sqrt(16))         # 4.0
    

    أخطاء شائعة

    • الدالة تُرجع None إلا إذا كتبت return. الطباعة ليست نفسها الإرجاع.
    • لا تستخدم أبداً قيمة افتراضية قابلة للتعديل مثل def f(x=[]) — نفس القائمة تُشارك بين جميع الاستدعاءات.
    • المتغير الذي يتم إنشاؤه داخل دالة يكون محلياً ولا يمكن رؤيته خارجها.
    • شغّل الدالة باستخدام f()؛ كتابة f وحدها تُسمّيه فقط.
  • 9 الأخطاء والاستثناءات والاختبار
    9.1

    الأخطاء والتشخيص

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

    أخطاء بايثون الشائعة: بناء الجملة، الاسم، النوع، الفهرس
    أخطاء بايثون الشائعة: بناء الجملة، الاسم، النوع، الفهرس
    # A runtime error, caught so this block still finishes:
    try:
        print(10 / 0)
    except ZeroDivisionError:
        print("cannot divide by zero")
    # cannot divide by zero
    
    • يطبع بايثون تتبعاً للخطأ يوضح مكان الفشل. اقرأه من الأسفل إلى الأعلى.
    9.2

    try / except / raise

    ضع الكود الخطير في try؛ إذا فشل، يلتقط except الاستثناء بدلاً من انهيار البرنامج.

    def to_int(text):
        try:
            return int(text)
        except ValueError:
            return 0
    print(to_int("abc"))   # 0
    
    • التقط نوعاً محدداً (ValueError، ZeroDivisionError، …).
    • raise يُنشئ خطأً خاصاً بك عن قصد.
    def set_age(age):
        if age < 0:
            raise ValueError("age cannot be negative")
        return age
    
    try:
        set_age(-1)
    except ValueError as err:
        print("error:", err)
    # error: age cannot be negative
    
    9.3

    الاختبار والصلابة

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

    def average(nums):
        if len(nums) == 0:        # edge case: empty list
            return 0
        return sum(nums) / len(nums)
    
    print(average([2, 4, 6]))     # 4.0
    print(average([]))            # 0
    
    • الكود القوي يتعامل مع المدخلات الغريبة بهدوء دون انهيار.

    أخطاء شائعة

    • لا تستخدم except: عاري — التقط الخطأ المحدد، مثلاً except ValueError:.
    • خطأ بناء الجملة يوقف البرنامج بالكامل قبل أن يعمل، لذا إصلاحها أولاً.
    • اختبر حالات الحواف (الإدخال الفارغ، الصفر، أكبر قيمة)، ليس فقط الحالة السهلة.
  • 10 الملفات
    10.1

    قراءة وكتابة ملفات النص

    ملف نصي يخزن النص على القرص. افتحه باستخدام open(name, mode) حيث يشير الوضع إلى القراءة أو الكتابة. استخدم دائماً with، الذي يغلق الملف عنك.

    الكتابة

    وضع "w" يكتب ملفاً جديداً ويمسح أي ملف قديم.

    with open("notes.txt", "w") as f:
        f.write("first line\n")
        f.write("second line\n")
    print("saved")            # saved
    

    القراءة

    وضع "r" (الافتراضي) يقرأ. .read() يُرجع الملف بأكمله كسلسلة واحدة.

    with open("notes.txt", "w") as f:
        f.write("hello\nworld\n")
    with open("notes.txt") as f:
        print(f.read().strip())   # hello / world
    

    سطراً بسطر

    مرر على الملف للحصول على سطر واحد في كل مرة. .strip() يزيل السطر الجديد في النهاية.

    with open("data.txt", "w") as f:
        f.write("Mei,88\nSam,71\n")
    with open("data.txt") as f:
        for line in f:
            name, score = line.strip().split(",")
            print(name, "scored", score)
    # Mei scored 88
    # Sam scored 71
    

    الإضافة

    وضع "a" يُضيف — يضيف في النهاية دون مسح.

    with open("log.txt", "w") as f:
        f.write("line 1\n")
    with open("log.txt", "a") as f:
        f.write("line 2\n")
    with open("log.txt") as f:
        print(f.read().strip())   # line 1 / line 2
    
    الوضع المعنى
    "r" قراءة (افتراضي)
    "w" كتابة (يمسح أولاً)
    "a" إضافة (إضافة في النهاية)

    أخطاء شائعة

    • أغلق الملف دائماً، أو استخدم with open(...) as f: الذي يغلقه عنك.
    • تُعيد read() الملف كاملاً كنص واحد، ولا تزال كل سطر ينتهي بـ \n.
    • فتحه بـ "w" يمسح الملف أولاً؛ استخدم "a" للإضافة في النهاية.
    open → read/write → close (with auto-closes)
    open → read/write → close (with auto-closes)
  • 11 تصميم الخوارزمية
    11.1

    الخوارزميات والتفكيك

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

    # Algorithm: find the largest number in a list
    def largest(nums):
        best = nums[0]
        for n in nums:
            if n > best:
                best = n
        return best
    
    print(largest([3, 9, 2, 7]))   # 9
    
    • التجريد يعني تجاهل التفاصيل: تستخدم largest(...) دون إعادة قراءة كيفية عملها.
    11.2

    الكود الوهمي والمخططات الانسيابية

    الكود الوهمي هو لغة إنجليزية بسيطة ومنظمة لخوارزمية، تُكتب قبل الكود الحقيقي. لا يتم تشغيله.

    SET best TO first number
    FOR Each number n
        IF n > best
          THEN
            SET best TO n
    OUTPUT best
    

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

    11.3

    الاستدعاء الذاتي ومكدس الاستدعاءات

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

    مكدس الاستدعاء لـ factorial(3): كل استدعاء ينتظر، ثم يعود بالترتيب العكسي
    مكدس الاستدعاءات لـ factorial(3): كل استدعاء ينتظر ثم يُعيد النتيجة بالعكس
    def fact(n):
        return 1 if n <= 1 else n * fact(n - 1)
    
    print(fact(5))     # 120
    
    • كل استدعاء متوقف يجلس على مكدس الاستدعاءات حتى يرجع الاستدعاء الذي فوقه.

    أخطاء شائعة

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

    أنواع البيانات المجردة (ADTs)

    نوع بيانات تجريدي (ADT) يصف بعض البيانات بالإضافة إلى العمليات عليها، منفصلة عن كيفية بنائها. تستخدمه من خلال عملياته، وليس من خلال تخزينه الداخلي.

    # A stack ADT, built on a list
    s = []
    s.append(1)        # add
    s.append(2)
    print(s.pop())     # 2  (remove the most recent)
    
    12.2

    المكدسات

    المكدس هو آخر الداخل، أول الخارج (LIFO). تدفع للأعلى وتُخرج من الأعلى.

    يتم إزالة العنصر من الأعلى في المكدس (LIFO)؛ وفي الطابور يتم الإزالة من الأمام (FIFO)
    يتم إزالة العنصر من الأعلى في المكدس (LIFO)؛ وفي الطابور يتم الإزالة من الأمام (FIFO)
    stack = []
    stack.append("a")
    stack.append("b")
    print(stack.pop())   # b
    print(stack.pop())   # a
    
    12.3

    الطوابير

    الطابور هو أول الداخل، أول الخارج (FIFO). تضيف في الخلف وتُخرج من الأمام.

    queue = []
    queue.append("a")     # enqueue
    queue.append("b")
    print(queue.pop(0))   # a  (dequeue the front)
    print(queue.pop(0))   # b
    
    12.4

    القوائم المترابطة

    قائمة مترابطة هي سلسلة من العقد. كل عقدة تحتوي على بيانات ومؤشر للعقدة التالية؛ الأخيرة تشير إلى None.

    قائمة مرتبطة: كل عقدة تحتوي على بيانات ومؤشر إلى العقدة التالية، وتنتهي بـ None
    قائمة مرتبطة: كل عقدة تحتوي على بيانات ومؤشر إلى العقدة التالية، وتنتهي بـ None
    n3 = {"data": 3, "next": None}
    n2 = {"data": 2, "next": n3}
    n1 = {"data": 1, "next": n2}
    node = n1
    while node is not None:      # traverse to the end
        print(node["data"])
        node = node["next"]
    # 1 2 3
    
    12.5

    الجداولIMATION

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

    دالة تجزئة تربط كل مفتاح بمكان؛ يمكن أن يتصادم مفتاحان في نفس المكان
    دالة التجزئة تربط كل مفتاح بمكان؛ يمكن أن يتصادم مفتاحان في نفس المكان
    table = {}
    table["Mei"] = 88
    table["Sam"] = 71
    print(table["Mei"])   # 88  (fast lookup by key)
    
    12.6

    أشجار البحث الثنائية

    شجرة البحث الثنائية (BST) تحافظ على الترتيب: كل ابن يسار أصغر من عقده، وكل ابن يمين أكبر. يبقى البحث سريعاً.

    شجرة بحث ثنائية: القيم الأصغر تذهب لليسار، والقيم الأكبر تذهب لليمين
    شجرة بحث ثنائية: القيم الأصغر تذهب لليسار، والقيم الأكبر تذهب لليمين
    def insert(root, val):
        if root is None:
            return {"val": val, "left": None, "right": None}
        if val < root["val"]:
            root["left"] = insert(root["left"], val)
        else:
            root["right"] = insert(root["right"], val)
        return root
    
    def inorder(root):
        if root is None:
            return []
        return inorder(root["left"]) + [root["val"]] + inorder(root["right"])
    
    tree = None
    for v in [5, 3, 8, 1, 4]:
        tree = insert(tree, v)
    print(inorder(tree))   # [1, 3, 4, 5, 8]
    
    12.7

    الرسوم البيانية

    الرسم البياني هو مجموعة من الرؤوس متصلة بحواف. قائمة الجوار — وهي قاموس بقوائم للجيران — طريقة شائعة لتخزينه.

    رسم بياني للرؤوس والحواف، مع شكل قائمة الجوار الخاص به
    رسم بياني للرؤوس والحواف، مع شكل قائمة الجوار الخاص به
    graph = {"A": ["B", "D"], "B": ["A", "C"], "C": ["B", "D"], "D": ["A", "C"]}
    for vertex in graph:
        print(vertex, "->", graph[vertex])
    # A -> ['B', 'D']  (and so on for B, C, D)
    

    أخطاء شائعة

    • المكدس (Stack) مبدأه آخر يدخل أول يخرج؛ الطابور (Queue) مبدأه أول يدخل أول يخرج. لا تخلط بينهما.
    • تحقق مما إذا كانت البنية فارغة قبل إزالة عنصر منها أو إخراج العنصر الأول منها.
    • في القائمة المرتبطة، فقدان المؤشر head يعني فقدان القائمة بأكملها.
  • 13 البحث، الفرز والكفاءة
    13.1

    البحث الخطي ثنائي التفرع

    البحث يعثر على مكان قيمة ما. البحث الخطي يفحص كل عنصر بالتتابع، لذا يعمل على أي قائمة.

    def linear_search(items, target):
        for i in range(len(items)):
            if items[i] == target:
                return i
        return -1     # not found
    
    print(linear_search([4, 8, 2, 9], 2))   # 2
    

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

    def binary_search(items, target):
        lo, hi = 0, len(items) - 1
        while lo <= hi:
            mid = (lo + hi) // 2
            if items[mid] == target:
                return mid
            elif items[mid] < target:
                lo = mid + 1
            else:
                hi = mid - 1
        return -1
    
    print(binary_search([1, 3, 5, 7, 9], 7))   # 3
    
    البحث الثنائي يقسم النطاق إلى نصفين في كل خطوة — O(log n) على قائمة مرتبة
    البحث الثنائي يقسم النطاق إلى نصفين في كل خطوة — O(log n) على قائمة مرتبة
    13.2

    الفرز (فقاعي وإدراج)

    الفرز هو وضع العناصر في ترتيب. الفرز الفقاعي يقوم بتبديل الأقران المتتاليين اللذين ليسا في الترتيب الصحيح بشكل متكرر.

    def bubble_sort(a):
        a = a[:]                          # work on a copy
        for i in range(len(a)):
            for j in range(len(a) - 1 - i):
                if a[j] > a[j + 1]:
                    a[j], a[j + 1] = a[j + 1], a[j]
        return a
    
    print(bubble_sort([5, 2, 4, 1]))      # [1, 2, 4, 5]
    

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

    def insertion_sort(a):
        a = a[:]                           # work on a copy
        for i in range(1, len(a)):
            key = a[i]
            j = i - 1
            while j >= 0 and a[j] > key:   # shift bigger values right
                a[j + 1] = a[j]
                j -= 1
            a[j + 1] = key                 # drop key into the gap
        return a
    
    print(insertion_sort([5, 2, 4, 1]))   # [1, 2, 4, 5]
    
    • في الكود الفعلي، استخدم الدالة المدمجة Python sorted():
    print(sorted([5, 2, 4, 1]))           # [1, 2, 4, 5]
    
    13.3

    كفاءة الخوارزميات

    الكفاءة تسأل كيف ينمو العمل مع نمو المدخلات. نصفها باستخدام Big-O.

    كيف ينمو عدد الخطوات مع حجم المدخلات للتعقيدات الشائعة
    كيف ينمو عدد الخطوات مع حجم المدخلات للتعقيدات الشائعة
    Big-O الاسم مثال
    $O(1)$ ثابت البحث عن مفتاح في قاموس
    $O(\log n)$ لوغاريتمي البحث الثنائي
    $O(n)$ خطي البحث الخطي
    $O(n^2)$ تربيعي الفرز الفقاعي
    def steps(n):           # how many steps a linear scan takes
        count = 0
        for i in range(n):
            count = count + 1
        return count
    
    print(steps(100))       # 100  -> O(n)
    
    13.4

    العشوائية والمحاكاة

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

    import random
    random.seed(0)
    rolls = [random.randint(1, 6) for _ in range(1000)]
    print(rolls.count(6))   # about 1/6 of 1000
    

    أخطاء شائعة

    • البحث الثنائي يعمل فقط على قائمة مرتبة.
    • Big-O يخبرك بكيفية نمو الوقت، وليس الوقت الدقيق؛ طريقة O(n²) تفوق O(n) فقط للمدخلات الصغيرة جداً.
    • الفرز الفقاعي هو O(n²) — جيد للتعلم، لكن بطيء على القوائم الكبيرة.
  • 14 OOP والنماذج البرمجية
    14.1

    الفئات والكائنات

    الفئة هي مخطط. الكائن هو شيء مبني منها (مثيل). __init__ هو البناء الذي يُعدّ كل كائن؛ self هو الكائن نفسه.

    class Dog:
        def __init__(self, name):
            self.name = name            # an attribute
        def speak(self):
            return self.name + " says woof"
    
    d = Dog("Rex")
    print(d.speak())     # Rex says woof
    
    • name هو سمة (بيانات على الكائن)؛ speak هي دالة (عمل).

    أضف __str__ للتحكم في عرض print(obj):

    class Dog:
        def __init__(self, name):
            self.name = name
        def __str__(self):
            return f"Dog named {self.name}"
    
    print(Dog("Rex"))    # Dog named Rex
    
    الفئة هي مخطط؛ استدعاؤها تنشئ كائناً
    الفئة هي مخطط؛ استدعاؤها تنشئ كائناً
    14.2

    الوراثة، التغليف، والتعدد الشكل

    الوراثة تسمح للفئة الفرعية بإعادة استخدام الفئة الأب. استخدم super() لاستدعاء الأب؛ عدّل دالة لتغييرها.

    class Animal:
        def speak(self):
            return "some sound"
    
    class Cat(Animal):
        def speak(self):                # override
            return "meow"
    
    print(Cat().speak())   # meow
    

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

    class Account:
        def __init__(self):
            self._balance = 0           # non-public by convention
        def deposit(self, n):
            self._balance += n
        def balance(self):
            return self._balance
    
    a = Account()
    a.deposit(50)
    print(a.balance())     # 50
    

    التعدد الشكل يعني اسماً واحداً، سلوكيات متعددة — الدالة speak الصحيحة تعمل لكل كائن.

    class Cat:
        def speak(self):
            return "meow"
    
    class Cow:
        def speak(self):
            return "moo"
    
    for animal in [Cat(), Cow()]:
        print(animal.speak())   # meow, then moo
    
    14.3

    نماذج البرمجة

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

    def total(nums):           # procedural
        t = 0
        for n in nums:
            t += n
        return t
    print(total([1, 2, 3]))    # 6
    
    print(sum([1, 2, 3]))      # 6  (declarative: same result)
    

    أخطاء شائعة

    • كل دالة تحتاج self كمعامل أول.
    • __init__ يُعدّ كائناً جديداً ويعمل تلقائياً عند إنشائه.
    • كائنان من نفس الفئة لديهما سمات منفصلة؛ تغيير أحدهما لا يغير الآخر.
  • 15 تمثيل البيانات
    15.1

    البتات والثنائية

    البيت هو 0 أو 1 فردي. النظام الثنائي هو نظام العد ذو الأساس 2: قيمة كل خانة ضعف ما على يمينها (1، 2، 4، 8، …). النظام العشري (الأساس 10) هو أرقامنا العادية.

    قيم خانات النظام الثنائي: 1101 تعني 8 + 4 + 1 = 13
    قيم خانات النظام الثنائي: 1101 تعني 8 + 4 + 1 = 13
    print(bin(13))         # 0b1101
    print(int("1101", 2))  # 13
    
    • 8 بتات تصنع بايت. العرض الثابت قد يتجاوز الحد (يدور حول) عندما يكون الرقم كبيراً جداً.
    x = 250
    x = (x + 10) % 256     # one byte wraps at 256
    print(x)               # 4
    

    الست عشرية (الأساس 16) هي طريقة مختصرة لقراءة النظام الثنائي: رقمة ست عشرية واحدة تقابل بالضبط أربعة بتات. Python يكتب الست عشرية باستخدام 0x:

    print(hex(255))        # 0xff
    print(0xFF)            # 255
    print(int("ff", 16))   # 255
    
    15.2

    الضغط

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

    ترميز المسارات المتتالية هو طريقة ضغط بدون فقدان بسيطة: تخزن المسار (التكرار) كعدد تكرارات وقيمة.

    def rle(text):
        out = ""
        i = 0
        while i < len(text):
            run = 1
            while i + run < len(text) and text[i + run] == text[i]:
                run += 1
            out += str(run) + text[i]
            i += run
        return out
    
    print(rle("AAAABBBCCD"))   # 4A3B2C1D
    

    أخطاء شائعة

    • n بتات تخزن 2**n قيم مختلفة، من 0 حتى 2**n - 1.
    • الضغط بفقدان يزيل التفاصيل ولا يمكن عكسه؛ الضغط بدون فقدان يمكن عكسه بدقة.
  • 16 مفاهيم الحوسبة
    16.1

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

    الحوسبة تعني حل المشكلات باستخدام الحواسيب: إدخال، معالجة، إخراج. البرمجيات الجيدة تُبنى في دورة تصميم — تخطيط، كتابة، اختبار، تحسين — تتكرر مرات عديدة.

    • قسم المشكلة، بِنِ جزءاً صغيراً، اختبره، ثم أضف المزيد.
    • المبرمجون يعملون في فرق ويعيدون استخدام أكواد بعضهم البعض.
    16.2

    الإنترنت

    إنترنت هو شبكة شبكات. البيانات مقسمة إلى حزم تسافر بشكل منفصل وتُعاد تجميعها في الطرف الآخر. قواعد مشتركة تسمى بروتوكولات (مثل TCP/IP) تجعل هذا ممكنًا. إذا تعطل مسار، تأخذ الحزم طريقاً آخر — وهذا redundancy، والذي يمنح تحمل الأخطاء.

    خريطة للإنترنت: كل خط هو مسار بين شبكتين
    خريطة للإنترنت: كل خط هو مسار بين شبكتين
    الطبقة المهمة
    HTTP طلب وإرسال صفحات الويب
    TCP توصيل موثوق، بالترتيب
    عنوان IP والتوجيه
    16.3

    الحوسبة المتوازية والموزعة

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

    • لا يمكن تشغيل كل شيء بالتوازي: بعض الخطوات يجب أن تنتظر نتيجة سابقة.
    16.4

    تأثير الحوسبة

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

    أخطاء شائعة

    • الإنترنت وشبكة المعلومات العالمية (World Wide Web) ليسا نفس الشيء: الشبكة هي خدمة واحدة تعمل فوق الإنترنت.
    • زيادة عدد أنوية المعالج تساعد فقط إذا كان العمل قابلاً للتقسيم إلى أجزاء تعمل في نفس الوقت.
  • 17 دمج العناصر معًا
    17.1

    مشاريع مصغرة شاملة

    يجمع المشروع المصغر بين الأفكار السابقة: بيانات في قائمة، ودالة تحتوي على اختيار داخل حلقة، ومخرجات مطبوعة. هذا هو أيضاً شكل مهمة الأداء الإبداعي (AP Create Performance Task).

    مشروع: متوسط العلامات

    def average(marks):
        if len(marks) == 0:
            return 0
        return round(sum(marks) / len(marks), 1)
    
    print(average([88, 71, 95, 60]))   # 78.5
    

    مشروع: عد النجاحات

    def count_passes(marks, pass_mark=60):
        passes = 0
        for m in marks:                 # iteration
            if m >= pass_mark:          # selection
                passes += 1
        return passes
    
    print(count_passes([88, 50, 95, 60]))   # 3
    

    مشروع: تصفية إلى قائمة جديدة

    def merit(marks):
        return [m for m in marks if m >= 80]
    
    print(merit([88, 71, 95, 60]))     # [88, 95]
    

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

    أخطاء شائعة

    • بنِ بخطوات صغيرة واختبر كل جزء قبل الانتقال إليه — لا تكتب الكود بالكامل دفعة واحدة.
    • اقرأ المهمة كاملة أولاً، ثم خطط للمدخلات → المعالجة → المخرجات قبل كتابة الكود.
    مشروع مصغر: بيانات ← دالة ← ناتج مطبوع
    مشروع مصغر: بيانات ← دالة ← ناتج مطبوع

تسجيل الدخول أو إنشاء حساب

IGCSE, A-Level & AP