العمليّات (الدوال)

7.1 العمليّات كأداة لتفصيل المهام وتقسيمها – פעולות ככלי לעידון וחלוקת משימות

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

v = 12
r = 480
print("V =", v, " R =", r)
print("I =", v / r, "A")
v = 5
r = 250
print("V =", v, " R =", r)
print("I =", v / r, "A")

V = 12  R = 480
I = 0.025 A
V = 5  R = 250
I = 0.02 A

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

def show_current(v, r):
    print("V =", v, " R =", r)
    print("I =", v / r, "A")

show_current(12, 480)
show_current(5, 250)

V = 12  R = 480
I = 0.025 A
V = 5  R = 250
I = 0.02 A

المُخرَج هو نفسه تماما. نقرأ التعريف (הגדרה) من اليسار:

• الكلمة المحجوزة def تعلن أن هنا تعريف عمليّة، وshow_current هو اسمها، بقواعد أسماء المتغيّرات.
• (v, r) هما الوسيطان: القيمتان اللتان تحتاج إليهما العمليّة. والقوسان ضروريان حتى لو لم يكن بينهما شيء، وبعدهما نقطتان.
• الأسطر المُزاحة تحت السطر الأول هي جسم العمليّة (גוף הפעולה)، كما في جسم الشرط وجسم الحلقة.
• السطر show_current(12, 480) هو الاستدعاء (זימון): هنا فقط يعمل الجسم.

الدوال الجاهزة التي نعرفها، مثل len وround، هي عمليّات كتبها مبرمجو بايثون. لكن الفائدة الكبرى ليست في منع التكرار، بل في طريقة التفكير. التفصيل التدريجي (עידון) يعني أن ننظر إلى المهمة الكبيرة، ونقسمها إلى مهام أصغر، ونواصل التقسيم حتى تصبح كل مهمة صغيرة بحيث نعرف كيف نكتبها.

7.2 تحديد دور العمليّة – הגדרת תפקיד הפעולות

قبل أن نكتب الجسم نحدد دور العمليّة، بأن نجيب عن أربعة أسئلة: ما اسمها؟ ماذا تستقبل؟ ماذا تعطي؟ وماذا تفعل بجملة واحدة؟ نجرّب ذلك على دوال نعرفها، وفي السطر الأخير على عمليّة سنكتبها:

• دور واحد لكل عمليّة. إذا احتجنا في وصفها إلى كلمة «ثم»، فربما هي عمليّتان.
• الاسم يقول الدور: read_batch يقرأ، وis_ok يسأل. الاسم الواضح يغني عن الشرح.
• العمليّة التي تحسب لا تقرأ ولا تطبع: تستقبل وسائط وتعيد نتيجة. فلو قرأت القياس بنفسها لما استطعنا أن نحسب بها مئة قياس محفوظة في قائمة.

ويمكن أن نكتب الدور في أول سطر من الجسم بين علامات اقتباس ثلاثية، وهذه جملة توثيق (מחרוזת תיעוד) لا تؤثر في التنفيذ، وسنرى واحدة في العمليّة deviation في البند 7.4.

التعريف لا ينفّذ شيئا. عندما يصل البرنامج إلى def يحفظ العمليّة باسمها ويتجاوز جسمها. الجسم يعمل عند الاستدعاء فقط، وفي كل استدعاء من جديد. لذلك لم يُطبع شيء عند سطر التعريف، وطُبعت الكلمة beep في الاستدعاءين فقط:

print("start")

def beep():
    print("beep")

beep()
print("end")
beep()

start
beep
end
beep

def mystery(bits, n):
    k = 0
    for b in bits:
        if b == 1:
            k += 1
    print(k >= n)

mystery([1, 0, 1, 1], 3)
mystery([1, 0, 0, 1], 3)

7.3 عمليّات تستقبل وسائط، ومنها وسائط بقيمة افتراضية – פעולות המקבלות פרמטרים, כולל פרמטרים עם ערך ברירת מחדל

def show_current(v, r):
    print("I =", round(v / r, 3), "A")

show_current(12, 480)
show_current(480, 12)
show_current(r=480, v=12)

I = 0.025 A
I = 40.0 A
I = 0.025 A

def led_series(vs, vf=2.0, i=0.02):
    r = (vs - vf) / i
    print("R =", round(r), "ohm")

led_series(12)
led_series(5, 3.2)
led_series(5, 3.2, 0.01)
led_series(5, i=0.01)

R = 500 ohm
R = 90 ohm
R = 180 ohm
R = 300 ohm

def show(x, k=2, d=0):
    print(x * k + d)

show(3)
show(3, 4)
show(3, d=1)
show(3, 4, 1)

7.4 عمليّات تعيد قيمة – פעולות המחזירות ערך

نكتب قانون أوم عمليّةً تعيد التيار. الاستدعاء يساوي القيمة المُعادة، ولذلك نستطيع أن نضعه في متغيّر، أو نكتبه داخل تعبير، أو نمرّره إلى print:

def current(v, r):
    return v / r

i = current(12, 480)
print(i)
print(current(9, 300) * 1000, "mA")
print(current(5, 250) + current(12, 400))

0.025
30.0 mA
0.05

def current(v, r):
    print(v / r)

i = current(12, 480)
print(i * 1000)

0.025
TypeError: unsupported operand type(s) for *: 'NoneType' and 'int'

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

def deviation(nominal, measured):
    """Deviation from the nominal value, in percent."""
    return abs(measured - nominal) * 100 / nominal

def is_ok(nominal, measured, tol=5):
    return deviation(nominal, measured) <= tol

print(deviation(1000, 1030))
print(is_ok(1000, 1030))
print(is_ok(1000, 1080))
print(is_ok(1000, 1080, 10))
if not is_ok(470, 500):
    print("Reject")

3.0
True
False
True
Reject

وإذا أردنا أن نعيد أكثر من قيمة كتبنا بينها فاصلة. تصل القيم في صفّ ثابت واحد، ونستطيع أن نفرّقها على متغيّرات، كما في v, i = 12, 0.5 من البند 2.6. نحسب مثلا أعلى جهد وأعلى تيار تتحملهما مقاومة قدرتها معروفة:

def limits(r, p):
    v = (p * r) ** 0.5
    i = (p / r) ** 0.5
    return round(v, 1), round(i, 3)

volts, amps = limits(470, 0.25)
print(volts, "V")
print(amps, "A")
print(limits(100, 1))

10.8 V
0.023 A
(10.0, 0.1)

def parallel(r1, r2):
    return r1 * r2 / (r1 + r2)

print(parallel(100, 300))
print(parallel(parallel(100, 300), 75))

7.5 عمليّات لا تعيد قيمة – פעולות שאינן מחזירות ערך

بعض العمليّات دورها أن تفعل شيئا لا أن تحسب: تطبع جدولا، أو تشغّل جهازا. لا return فيها، أو فيها return من دون قيمة. وعندها يكون الاستدعاء أمرا قائما بذاته، لا جزءا من تعبير. وما يعود منها هو القيمة الخاصة None التي تعني «لا شيء»:

def rule(n, ch="-"):
    print(ch * n)

rule(12)
rule(6, "=")
x = rule(3)
print(x)

------------
======
---
None

def show_current(v, r):
    if r == 0:
        print("Short circuit")
        return
    print("I =", v / r, "A")

show_current(12, 0)
show_current(12, 480)

Short circuit
I = 0.025 A

def mark(v, top=5):
    if v > top:
        print(v, "high")
        return
    print(v, "ok")

mark(3)
mark(7)
mark(7, 8)
print(mark(9))

7.6 استدعاء العمليّات – זימון פעולות

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

العمليّة تستدعي عمليّة. هذا هو التقسيم الذي تحدثنا عنه، ورأيناه في البند 7.4: is_ok تستدعي deviation، والعودة تصل دائما إلى من استدعى.

def to_base(value, prefix):
    if prefix == "k":
        return value * 1000
    if prefix == "m":
        return value / 1000
    return value

print(12 / to_base(4.8, "k"))
print(to_base(250, "m"))
print(round(to_base(9, "") / to_base(4.7, "k") * 1000, 2), "mA")

0.0025
0.25
1.91 mA

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

def twice(x):
    print("twice", x)
    return 2 * x

def plus(a, b):
    print("plus", a, b)
    return a + b

print(plus(twice(1), twice(3)))

7.7 جدول المتابعة – טבלת מעקב

نوسّع جدول المتابعة من البند 2.16 بنوعين من الأعمدة: عمود لكل متغيّر محلي نكتب فوقه اسم العمليّة، وعمود للقيمة المُعادة نكتب فوقه power().

def power(v, i):
    p = v * i
    return p

a = power(12, 2)
b = power(5, 3)
print(a + b)

• الأعمدة التي تبدأ بـ power. هي متغيّرات العمليّة، ومنها الوسيطان. وتظهر قيم الوسيطين في أول سطر من الجسم، كما هي بعد تنفيذ هذا السطر.
• سطر الاستدعاء a = power(12, 2) يبدأ فارغا، لأنه لم ينتهِ بعد. ونسجّل قيمة a في الجدول في سطر return p، حيث تعود القيمة، وفي السطر نفسه نسجّل المُخرَج أيضا عندما يكون الاستدعاء داخل print.
• في كل استدعاء تولد متغيّرات العمليّة من جديد، ولا علاقة لها بالاستدعاء السابق.

def limit(v, top=5):
    if v > top:
        return top
    return v

x = limit(7)
y = limit(3)
print(x, y)

def fix(a, b=1):
    c = a + b
    if c > 5:
        c = c - 5
    return c

m = fix(3, 4)
print(m)

7.8 عمليّات تستقبل بنى معطيات وعمليّات تعيد بنى معطيات – פעולות המקבלות מבני נתונים, פעולות המחזירות מבני נתונים

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

def deviation(nominal, measured):
    return abs(measured - nominal) * 100 / nominal

def good_parts(nominal, batch, tol=5):
    good = []
    for m in batch:
        if deviation(nominal, m) <= tol:
            good.append(m)
    return good

batch = [1020, 940, 1049, 1100]
print(good_parts(1000, batch))
print(good_parts(1000, batch, 10))
print(len(good_parts(1000, batch, 1)))
print(batch)

[1020, 1049]
[1020, 940, 1049, 1100]
0
[1020, 940, 1049, 1100]

def led_series(vs, vf=2.0, i=0.02):
    return (vs - vf) / i

def nearest(values, target):
    best = values[0]
    for v in values:
        if abs(v - target) < abs(best - target):
            best = v
    return best

e12 = [100, 120, 150, 180, 220, 270,
       330, 390, 470, 560, 680, 820]
needed = led_series(12)
print(needed)
print(nearest(e12, needed))
print(nearest(e12, led_series(9)))

500.0
470
330

ماذا يحدث للقائمة داخل العمليّة؟:

الوسيط يشير إلى القائمة نفسها التي مررناها، لا إلى نسخة منها، كما رأينا في b = a في البند 6.4. لذلك يغيّر zero_negatives القائمة الأصلية، بخلاف good_parts التي تركتها كما هي وأعادت قائمة جديدة. نختار حسب الدور، ونقول ذلك في اسم العمليّة:

def zero_negatives(values):
    for i in range(len(values)):
        if values[i] < 0:
            values[i] = 0

a = [3, -1, 2, -5]
zero_negatives(a)
print(a)

[3, 0, 2, 0]

def reset(x, items):
    x = 0
    items[0] = 0
    items = []

n = 5
b = [5, 6]
reset(n, b)
print(n, b)

5 [0, 6]

def pick(values, k):
    result = []
    for i in range(0, len(values), k):
        result.append(values[i])
    return result

def bump(values):
    values[0] += 1

a = [1, 2, 3, 4, 5]
b = pick(a, 2)
bump(b)
print(a)
print(b)

7.9 استعمال المعامل * لحزم الوسائط وفكّها – שימוש באופרטור * כדי לארוז ולפרק פרמטרים (Packing and Unpacking)

الدالة print تقبل أي عدد من القيم. وبالمعامل * نكتب نحن أيضا عمليّات كهذه، وله دوران حسب مكانه:

المقاومة المكافئة لمقاومات على التوالي هي مجموعها، وعددها يختلف من دائرة إلى دائرة:

def series(*resistors):
    print(resistors)
    return sum(resistors)

print(series(100, 220))
print(series(100, 220, 470))
print(series())

(100, 220)
320
(100, 220, 470)
790
()
0

داخل العمليّة resistors صفّ ثابت عادي، قد يكون فارغا. ويمكن أن تأتي قبله وسائط عادية تأخذ القيم الأولى، وكل ما يبقى يدخل إلى الصفّ، كما في def report(name, *values):.

الفكّ هو الاتجاه المعاكس: عندنا قائمة، والعمليّة تريد قيما منفصلة. current(*pair) يعطي ما يعطيه current(pair[0], pair[1]) من دون أن نعدّ المؤشّرات، وعدد العناصر يجب أن يساوي عدد الوسائط. ومع print يطبع عناصر القائمة من دون أقواس:

def current(v, r):
    return v / r

def series(*resistors):
    return sum(resistors)

pair = [12, 480]
print(current(pair[0], pair[1]))
print(current(*pair))
parts = [100, 220, 470]
print(series(*parts))
print(parts)
print(*parts)
print(*parts, sep=" + ")

0.025
0.025
790
[100, 220, 470]
100 220 470
100 + 220 + 470

def top(limit, *values):
    n = 0
    for v in values:
        if v > limit:
            n += 1
    return n

data = [4, 9, 6]
print(top(5, 4, 9, 6))
print(top(5, *data))
print(top(*data))
print(top(5))

7.10 مدى رؤية المتغيّرات واستعمال global – טווח ההכרה של משתנים (שימוש ב-global) (global)

المتغيّر المحلي يختفي عندما تنتهي العمليّة، فإذا طبعناه بعدها توقف البرنامج بالخطأ NameError. والاسم نفسه داخل العمليّة وخارجها هو متغيّران منفصلان. نرى ذلك في جدول المتابعة: العمود current.i يتغيّر، والعمود i لا يتحرك:

i = 99

def current(v, r):
    i = v / r
    return i

a = current(12, 480)
print(a, i)

energy = 0

def add_load(watts, hours):
    energy = energy + watts * hours

add_load(60, 2)

الأمر global يقول: هذا الاسم هو المتغيّر العام نفسه، فلا تنشئ متغيّرا محليا. نكتبه في أول الجسم، ونجمع به طاقة أحمال المحطة:

energy = 0

def add_load(watts, hours):
    global energy
    energy = energy + watts * hours

add_load(60, 2)
add_load(100, 0.5)
print(energy, "Wh")

170.0 Wh

البرنامج يعمل، لكن من يقرأ add_load(60, 2) لا يعرف أنه يغيّر شيئا في الخارج، وعندما تكثر العمليّات لا نعرف أيها غيّر المتغيّر. لذلك نفضّل أن نمرّر القيمة وسيطا ونعيد النتيجة، فيظهر كل شيء في سطر الاستدعاء:

def add_load(energy, watts, hours):
    return energy + watts * hours

total = 0
total = add_load(total, 60, 2)
total = add_load(total, 100, 0.5)
print(total, "Wh")

170.0 Wh

a = 1
b = 2

def f(a):
    global b
    a = a + 10
    b = b + 10
    c = a + b
    return c

print(f(a))
print(a, b)

7.11 العمليّة main كنقطة دخول إلى البرنامج – הדגמה: שימוש בפעולה main כנקודת הכניסה לקוד התוכנית

الملف الذي كتبناه قد يُستورد إلى برنامج آخر بالأمر import، لكي يستعمل عمليّاته. لكن الاستيراد يشغّل كل ما في الملف، حتى الأوامر التي خارج العمليّات. لكي نمنع ذلك، تعطي بايثون كل ملف متغيّرا اسمه __name__: قيمته "__main__" عندما نشغّل الملف نفسه، وهي اسم الملف من دون اللاحقة .py عندما يُستورد. نجرّب مع ملف اسمه ohm.py، نشغّله مباشرة:

def current(v, r):
    return v / r

print("name is", __name__)

if __name__ == "__main__":
    print(current(12, 480))

name is __main__
0.025

والآن نستورده من برنامج آخر في المجلد نفسه. عمل الأمر غير المحمي، ولم يعمل ما تحت الشرط. لذلك يكون الأمر الذي تحت الشرط هو main() عادة:

import ohm

print(ohm.current(5, 250))

name is ohm
0.02

def deviation(nominal, measured):
    return abs(measured - nominal) * 100 / nominal

def read_batch():
    batch = []
    value = float(input("Measured (0 to stop): "))
    while value != 0:
        batch.append(value)
        value = float(input("Measured (0 to stop): "))
    return batch

def split_batch(nominal, batch, tol=5):
    good = []
    bad = []
    for m in batch:
        if deviation(nominal, m) <= tol:
            good.append(m)
        else:
            bad.append(m)
    return good, bad

def report(good, bad):
    print("Good:", len(good), good)
    print("Reject:", len(bad), bad)

def main():
    nominal = float(input("Nominal: "))
    batch = read_batch()
    good, bad = split_batch(nominal, batch)
    report(good, bad)

if __name__ == "__main__":
    main()

Nominal: 1000
Measured (0 to stop): 1020
Measured (0 to stop): 940
Measured (0 to stop): 1049
Measured (0 to stop): 1100
Measured (0 to stop): 0
Good: 2 [1020.0, 1049.0]
Reject: 2 [940.0, 1100.0]

7.12 الأمر pass كعلامة مكان لشيفرة مستقبلية – הוראת pass (כמציין מיקום עבור קוד עתידי) (pass)

جسم العمليّة لا يمكن أن يكون فارغا: إذا كتبنا التعريف وأردنا أن نعود إليه لاحقا، توقف البرنامج بالخطأ IndentationError. الأمر pass لا يفعل شيئا، وكل وظيفته أن يملأ المكان. وبه نكتب هيكل البرنامج (שלד) أولا، حسب التقسيم، ونشغّله قبل أن تكون فيه أي عمليّة حقيقية. البرنامج التالي مسجّل لعينات، كل عمليّة فيه ما زالت فارغة:

def read_sample():
    pass

def save_sample(sample):
    pass

def main():
    sample = read_sample()
    save_sample(sample)
    print("Skeleton runs", sample)

main()

Skeleton runs None

الهيكل يعمل، إذن فالأسماء وعدد الوسائط صحيحة. والقيمة None تذكّرنا بأن العمليّة التي جسمها pass لا تعيد شيئا. نملأ العمليّات واحدة بعد واحدة. ونستطيع أن نجعل read_sample تعيد قيمة ثابتة مؤقتا، مثل return 25.0، فنفحص ما بعدها قبل أن يكون بين أيدينا حسّاس.

def adc_to_volts(adc, scale=1):
    return adc * 5 / 1023 * scale

def is_number(text):
    digits = text.replace(".", "")
    return text.count(".") <= 1 and digits.isnumeric()

def parse_line(line):
    battery = -1.0
    temp = -1.0
    for item in line.split(";"):
        pos = item.find("=")
        text = item[pos + 1:]
        if pos == -1 or not is_number(text):
            return False, 0, 0
        if item[:pos] == "BAT":
            battery = float(text)
        elif item[:pos] == "TMP":
            temp = float(text)
    return battery >= 0 and temp >= 0, battery, temp

def decide(battery, temp):
    load = battery >= 11.8
    fan = temp > 40 and load
    return load, fan

def report(battery, temp):
    load, fan = decide(battery, temp)
    print("Battery:", round(battery, 2), "V")
    print("Temp:", round(temp, 1), "C")
    print("Load on:", load, " Fan on:", fan)

def main():
    adc_batt = int(input("ADC battery: "))
    adc_temp = int(input("ADC temp: "))
    battery = adc_to_volts(adc_batt, 4)
    temp = adc_to_volts(adc_temp, 100)
    report(battery, temp)
    line = input("Line: ")
    ok, battery, temp = parse_line(line)
    if ok:
        report(battery, temp)
    else:
        print("Line rejected")

if __name__ == "__main__":
    main()

ADC battery: 620
ADC temp: 82
Battery: 12.12 V
Temp: 40.1 C
Load on: True  Fan on: True
Line: BAT=12.42;TMP=31.5
Battery: 12.42 V
Temp: 31.5 C
Load on: True  Fan on: False

أهمّ أفكار الفصل:

• نقسم المهمة قبل أن نكتب، ولكل عمليّة دور واحد نقوله بجملة واحدة.
• التعريف لا ينفّذ شيئا؛ الجسم يعمل عند الاستدعاء فقط، وفي كل استدعاء من جديد.
• الاستدعاء يساوي القيمة المُعادة. return للبرنامج وprint للإنسان، وعمليّة بلا return تعيد None.
• القيم توزَّع على الوسائط حسب ترتيبها، والقيم الافتراضية في آخر قائمة الوسائط.
• القائمة التي نمرّرها هي نفسها، فتغيير عنصر فيها يصل إلى الخارج. أما الإسناد إلى الوسيط فلا يصل.
• المتغيّر المحلي يختفي بانتهاء العمليّة. ونفضّل الوسيط والقيمة المُعادة على global.
• البرنامج الكامل يبدأ من main، ونبدأ كتابته من هيكل فيه pass.

ملخّص أوامر الفصل:

قاموس المصطلحات – מילון מונחים:

أسئلة للتمرين:

def f(x, y=3):
    return x * y

def g(x):
    print(f(x) + 1)

g(2)
print(f(2, 2))
print(g(1))

def half_power(v, r):
    p = v * v / r
    print(p / 2)

result = half_power(12, 48)
print("Half power:", round(result, 2))

def half_power(v, r):
    p = v * v / r
    return p / 2

result = half_power(12, 48)
print("Half power:", round(result, 2))

def drop(i, r=100):
    return i * r

print(drop(0.02))
print(drop(0.02, 470))

def count_between(values, low, high):
    count = 0
    for v in values:
        if low <= v <= high:
            count += 1
    return count

print(count_between([4.7, 5.1, 5.0, 3.3], 4.9, 5.1))

def checksum(frame):
    return sum(frame) % 256

def is_intact(frame, received):
    return checksum(frame) == received

print(checksum([200, 100, 7]))
print(is_intact([200, 101, 7], 51))

def step(a, b):
    a = a + b
    b = b * 2
    return a, b

x, y = step(1, 2)
x, y = step(x, y)
print(x, y)

def lowest(*values):
    best = values[0]
    for v in values:
        if v < best:
            best = v
    return best

volts = [12.1, 11.7, 12.6]
print(lowest(9, 5, 7))
print(lowest(*volts))

def band_ohms(bands):
    colors = ("black", "brown", "red", "orange", "yellow",
              "green", "blue", "violet", "gray", "white")
    a = colors.index(bands[0])
    b = colors.index(bands[1])
    k = colors.index(bands[2])
    return (a * 10 + b) * 10 ** k

print(band_ohms(["yellow", "violet", "red"]))
print(band_ohms(["brown", "black", "orange"]))
print(band_ohms("red red brown".split()))

def to_bits(n, width=8):
    bits = ""
    for k in range(width):
        bits = str(n % 2) + bits
        n = n // 2
    return bits

print(to_bits(5))
print(to_bits(202) == bin(202)[2:])

def network(kind, *rs):
    if kind == "s":
        return sum(rs)
    total = 0
    for r in rs:
        total += 1 / r
    return round(1 / total, 2)

print(network("s", 100, 220))
print(network("p", 100, 100, 100))
print(network("s", 47, network("p", 100, 100)))

count = 0

def beep():
    global count
    count += 1
    print("beep", count)

beep()
beep()

def beep(count):
    count += 1
    print("beep", count)
    return count

count = 0
count = beep(count)
count = beep(count)

def nearest(values, target):
    best = values[0]
    for v in values:
        if abs(v - target) < abs(best - target):
            best = v
    return best

def standard(r):
    e12 = [10, 12, 15, 18, 22, 27, 33,
           39, 47, 56, 68, 82, 100]
    scale = 1
    while r >= 100:
        r = r / 10
        scale = scale * 10
    return nearest(e12, r) * scale

print(standard(500))
print(standard(1950))

שאלות בגרות – أسئلة بجروت للفصل 7

بجروت 2026 السؤال 9 — الخانة الأولى والخانة الأخيرة

البند	المطلوب	الإجابة
(أ)	مُخرَج الأوامر الثلاثة.	2 , 4 , 6
(ب)	قائمة تعيد لها العمليّة 0، وقائمة تعيد لها 5.	في الأسفل
(ج)	العمليّة sum_of_digits.	في الأسفل

الحل الكامل بالعربية: fahed-lab.com/exams/electronics-815381/815381/solutions/solution-2026

(أ) في عدد من ثلاث خانات، lst[i] // 100 هي خانة المئات وlst[i] % 10 هي خانة الآحاد، كما في البند 2.9. إذن تعدّ العمليّة الأعداد التي خانتها الأولى تساوي خانتها الأخيرة. ونجد الأعداد الثلاثة في جدول الإجابات أعلاه.

(ب) لا نحتاج إلا إلى مثال لكل قيمة. القائمة [100, 123, 450] لا يوجد فيها عدد خانتاه الطرفيتان متساويتان، فتعيد العمليّة 0. والقائمة [101, 212, 323, 434, 545] كل أعدادها كذلك، فتعيد 5. والنتيجتان من تشغيل العمليّة.

(ج) حسبنا هذا المجموع مباشرة لعدد واحد في آخر الفصل 2. الحساب هو نفسه، لكنه الآن عمليّة: الوسيط مكان القيمة الثابتة، وreturn مكان print:

def sum_of_digits(num):
    hundreds = num // 100
    tens = (num // 10) % 10
    ones = num % 10
    return hundreds + tens + ones

print(sum_of_digits(472))
print(sum_of_digits(900))

13
9

بجروت 2025 السؤال 9 — مقارنة عناصر متقابلة

البند	المطلوب	الإجابة
(أ)	مُخرَج الاستدعاءات الأربعة.	HHLL , LHHL , LLHH , HLLH
(ب)	قائمتان يطبع لهما البرنامج HHHH.	في الأسفل
(ج)	العمليّة IsTheSame.	في الأسفل

الحل الكامل بالعربية: fahed-lab.com/exams/electronics-815381/815381/solutions/solution-2025

(أ) هذه عمليّة لا تعيد قيمة: تطبع H عندما يتساوى العنصران في المؤشّر نفسه، وL عندما يختلفان، كلها في سطر واحد بفضل end=""، ثم تنتقل إلى السطر التالي بالأمر print() الأخير. نتابع الاستدعاء الثاني، ونجد الأسطر الأربعة في جدول الإجابات أعلاه:

(ب) الجواب HHHH يعني أن كل زوج متساوٍ، أي كل قائمتين متطابقتين من أربعة عناصر، مثل [7, 8, 9, 1] مع نفسها.

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

def IsTheSame(lst1, lst2):
    if len(lst1) != len(lst2):
        return False
    for i in range(len(lst1)):
        if lst1[i] != lst2[i]:
            return False
    return True

lst1 = [1, 2, 3, 4, 5]
lst2 = [1, 2, 3, 4, 5]
lst3 = [1, 2, 4, 4, 5]
b1 = IsTheSame(lst1, lst2)
b2 = IsTheSame(lst1, lst3)
print(b1, b2)
print(IsTheSame(lst1, [1, 2, 3]))

True False
False

بجروت 2024 السؤال 9 — خانة الآحاد والمكان

البند	المطلوب	الإجابة
(أ)	جدول متابعة للقائمة المعطاة، والقيمة المُعادة.	False
(ب)	قائمة تعيد لها True وقائمة تعيد لها False.	في الأسفل
(ج)	دور العمليّة بجملة واحدة.	في الأسفل
(د)	العمليّة IsInArray.	في الأسفل

الحل الكامل بالعربية: fahed-lab.com/exams/electronics-815381/815381/solutions/solution-2024

(أ) الأمر return False موجود داخل الحلقة، فإذا تحقق الشرط مرة واحدة خرجت العمليّة كلها ولم تكمل القائمة. والسؤال يطلب عمودا لشرط الحلقة أيضا. حلقة for لا شرط مكتوبا لها، لكن سطرها يسأل: هل بقي عنصر نأخذه؟ نسجّل الجواب في العمود for item in lst، ونقرأ في العمود item ما أخذه. والعمود return هو القيمة المُعادة:

عند العنصر 894 تكون خانة الآحاد 4 والمتغيّر i يساوي 5، فيتحقق الشرط وتعيد العمليّة False من غير أن تصل إلى العناصر الأربعة الباقية.

(ب) تعيد True عندما تساوي خانة الآحاد مكان العنصر في القائمة، وتعيد False عندما يختلفان في أي مكان. فالقائمة [50, 11, 72, 3] تعيد True، والقائمة [50, 11, 73, 3] تعيد False.

(ج) العمليّة تفحص هل خانة الآحاد في كل عنصر من القائمة تساوي مؤشّر هذا العنصر.

(د) البنية نفسها: نخرج بـ True عند أول عنصر مساوٍ، ولا نعيد False إلا بعد انتهاء الحلقة. الخطأ الشائع هو else: return False داخل الحلقة، فتتوقف العمليّة عند العنصر الأول. والسؤال يكتب true، وهي في بايثون True:

def IsInArray(lst, num):
    for item in lst:
        if item == num:
            return True
    return False

lst = [2, 3, 5, 6, 2, 4, 2]
b1 = IsInArray(lst, 2)
b2 = IsInArray(lst, 7)
print(b1, b2)

True False

بجروت 2023 السؤال 10 — مقارنة قائمتين

البند	المطلوب	الإجابة
(أ)	جدول متابعة والمُخرَج.	True
(ب)	تعريف المشكلة التي تحلها العمليّة لقائمتين متساويتين في الكبر.	في الأسفل
(ج)	العمليّة countEven (في النص العربي CountEven).	في الأسفل

الحل الكامل بالعربية: fahed-lab.com/exams/electronics-815381/815381/solutions/solution-2023

(أ) نضيف إلى الشيفرة السطر main_10() الذي يشغّلها. القائمتان متساويتان في الطول، فنصل إلى else، حيث يجمع s الفروق بين العناصر المتقابلة. لا نكتب عمودا للقائمتين لأن السؤال لا يطلب ذلك، ولا يتغيّر فيهما شيء:

في النهاية s يساوي صفرا، فلا يتغيّر b، والمُخرَج هو True.

(ب) s هو مجموع القائمة الأولى ناقص مجموع الثانية. لذلك: العمليّة تستقبل قائمتين متساويتين في الكبر، وتعيد True إذا كان مجموع عناصرهما متساويا، وإلا تعيد False. الترتيب لا يهم، والعناصر قد تختلف. فالعمليّة تعيد للقائمتين [1, 2, 3] و[3, 2, 1] القيمة True.

(ج) عدّاد مع شرط من الفصل 4، داخل عمليّة تستقبل قائمة وتعيد عددا:

def countEven(lst):
    count = 0
    for x in lst:
        if x % 2 == 0:
            count += 1
    return count

print(countEven([10, 15, 18, 2, 17]))
print(countEven([1, 3]))
print(countEven([]))

3
0
0