Python Handout · ⁨ورقة عمل Python⁩

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

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

print("Hello, world!")
print("I am learning Python")

• كل print() يبدأ سطرًا جديدًا.
• يمكن أن تكون علامات الاقتباس "double" أو 'single' — كلاهما يُنتج نصًا.
• لا يقوم البرنامج بأي شيء حتى تقوم بتشغيله.

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

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

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

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

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

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

name = input("What is your name? ")
print("Hello, " + name)

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

أخطاء شائعة

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

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

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

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

age = 17
age = age + 1   # age is now 18
print(age)

• علامة = لا تعني "يساوي". بل تعني "احفظ الجانب الأيمن تحت الاسم الأيسر".
• لاختبار ما إذا كانت قيمتان متساويتين، استخدم == (أنظر أدناه).

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

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

• / تُرجع دائمًا كسرًا عشريًا، لذا 4 / 2 هي 2.0.
• // و% يعملان معًا: 17 // 5 هي 3، و17 % 5 هي 2.

التعبير هو أي شيء له قيمة، مثل 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).

القيمة المنطقية (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 — تجنب == على نتائج الكسور العشرية.

النص هو نص داخل علامات تنصيص. لكل حرف موقع، يُسمى فهرسه. الفهرس الأول هو 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).

الشرطة تأخذ جزءًا من النص. اكتب 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

الدالة (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)

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

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

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

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() لن يفعل شيئًا إلا إذا قمت بتخزين النتيجة.

يختار البرنامج ما يجب فعله مع 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.

اجمع الشروط باستخدام 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 فقط.

الحلقة تكرر الكود. حلقة 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

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

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

تكرّر حلقة 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

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

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

أخطاء شائعة

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

تحفظ القائمة قيمًا عديدة بالترتيب، داخل []. لكل عنصر فهرس (من 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.
• يمكن للقائمة أن تكبر وتصغر؛ ولا يمكن للنص ذلك.

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

المرور على القائمة يعني زيارة كل عنصر. تقوم حلقة 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

القائمة متعددة الأبعاد 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

استيعاب القائمة يبني قائمة جديدة في سطر واحد: [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]

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

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].

التحفظ القاموس (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] تستبدل القيمة القديمة — المفاتيح فريدة.
• يجب أن تكون المفاتيح غير قابلة للتغيير، مثل النص أو الرقم — لا يمكن للقائمة أن تكون مفتاحًا.

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

def greet():
    print("Hello!")

greet()        # Hello!
greet()        # Hello!

• يعمل الكود بداخلها فقط عندما تستدعي الدالة.

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

def square(n):
    return n * n

print(square(5))          # 25
print(square(3) + 1)      # 10

• يُنهك return الدالة فوراً. أي دالة بدون return تُرجع None.

المعامل هو الاسم في 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

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

def area_of_rectangle(w, h):
    return w * h

print(area_of_rectangle(4, 5))   # 20

• الدالة الجيدة تقوم بوظيفة واحدة، لها اسم واضح، وتتجنب تكرار الكود.

الوحدة هي ملف يحتوي على دوال جاهزة. استورد إحداها باستخدام 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 وحدها تُسمّيه فقط.

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

# A runtime error, caught so this block still finishes:
try:
    print(10 / 0)
except ZeroDivisionError:
    print("cannot divide by zero")
# cannot divide by zero

• يطبع بايثون مسار التتبع (traceback) يُظهر أين فشل. اقرأه من الأسفل إلى الأعلى.

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

def to_int(text):
    try:
        return int(text)
    except ValueError:
        return 0

print(to_int("42"))    # 42
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

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

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:.
• خطأ بناء الجملة يوقف البرنامج بالكامل قبل أن يعمل، لذا إصلاحها أولاً.
• اختبر حالات الحواف (الإدخال الفارغ، الصفر، أكبر قيمة)، ليس فقط الحالة السهلة.

ملف نصي يخزن النص على القرص. افتحه باستخدام 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

أخطاء شائعة

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

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

# 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(...) دون إعادة قراءة كيفية عملها.

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

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

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

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

def fact(n):
    return 1 if n <= 1 else n * fact(n - 1)

print(fact(5))     # 120

• كل استدعاء متوقف يجلس على مكدس الاستدعاءات حتى يرجع الاستدعاء الذي فوقه.

أخطاء شائعة

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

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

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

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

stack = []
stack.append("a")
stack.append("b")
print(stack.pop())   # b
print(stack.pop())   # a

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

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

قائمة مترابطة هي سلسلة من العقد. كل عقدة تحتوي على بيانات ومؤشر للعقدة التالية؛ الأخيرة تشير إلى 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

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

table = {}
table["Mei"] = 88
table["Sam"] = 71
print(table["Mei"])   # 88  (fast lookup by key)

شجرة البحث الثنائية (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]

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

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 يعني فقدان القائمة بأكملها.

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

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

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

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]

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

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)

وحدة 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²) — جيد للتعلم، لكن بطيء على القوائم الكبيرة.

الفئة هي مخطط. الكائن هو شيء مبني منها (مثيل). __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

الوراثة تسمح للفئة الفرعية بإعادة استخدام الفئة الأب. استخدم 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           # private
    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

النمط هو أسلوب في كتابة البرامج. الكود الإجرائي هو سلسلة من الخطوات والدوال. الكود الموجه للكائنات يجمع البيانات والدوال في كائنات. الكود التصريحي يقول ماذا تريد، لا كيف (استيعاب قائمة أو 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__ يُعدّ كائناً جديداً ويعمل تلقائياً عند إنشائه.
• كائنان من نفس الفئة لديهما سمات منفصلة؛ تغيير أحدهما لا يغير الآخر.

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

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

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

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

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.
• الضغط بفقدان يزيل التفاصيل ولا يمكن عكسه؛ الضغط بدون فقدان يمكن عكسه بدقة.

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

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

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

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

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

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

أخطاء شائعة

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

يجمع المشروع المصغر بين الأفكار السابقة: بيانات في قائمة، ودالة تحتوي على اختيار داخل حلقة، ومخرجات مطبوعة. هذا هو أيضاً شكل مهمة الأداء الإبداعي (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 إبداع قائمة، وإجراء معلمات يستخدم فيه الاختيار والتكرار، وبعض المدخلات/المخرجات. كل مشروع أعلاه يأخذ هذا الشكل تماماً — بنِ قطعاً صغيرة، ثم ادمجها.

أخطاء شائعة

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