التنفيذ المتكرر

4.1 الحاجة إلى التنفيذ المتكرر – הצורך בביצוע חוזר

نريد متوسط ثلاث قراءات لحسّاس. بما تعلمناه حتى الآن نكتب الأمرين نفسيهما ثلاث مرات:

total = 0
value = float(input("Sample: "))
total += value
value = float(input("Sample: "))
total += value
value = float(input("Sample: "))
total += value
print("Average:", total / 3)

البرنامج صحيح، لكنه لا يصلح إذا صارت القراءات مئة. سنضطر إلى نسخ مئتي سطر، وأي تصحيح سيتكرر مئة مرة. والأسوأ من ذلك أننا أحيانا لا نعرف العدد مسبقا: كم قراءة ستصل قبل أن يوقف المستخدم الجهاز؟ لا يوجد عدد نسخ يكفي لسؤال كهذا.

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

total = 0
n = 1
while n <= 3:
    value = float(input("Sample: "))
    total += value
    n += 1
print("Average:", total / 3)

Sample: 20.5
Sample: 21
Sample: 21.5
Average: 21.0

وهناك حالة ثانية لا تحلها أي نسخة، لأن عدد الدورات ينتج عن الحساب نفسه:

volts = 12.0
steps = 0
while volts >= 1:
    volts = volts / 2
    steps += 1
print("Steps:", steps)
print("Volts:", volts)

Steps: 4
Volts: 0.75

4.2 البنية الأساسية للحلقة while – תחביר בסיסי של לולאת while

الأمر while يعني «ما دام». نكتبه هكذا:

while condition:
    statement
    statement
next_statement

• بعد الشرط نقطتان :، كما في if، وبدونهما لا يبدأ البرنامج.
• الأوامر المزاحة هي جسم الحلقة (גוף הלולאה)، وهي التي تتكرر.
• يُفحص الشرط قبل كل دورة. إذا تحقّق نُفِّذ الجسم كله ثم عدنا إلى الشرط، وإذا لم يتحقّق انتقلنا إلى الأمر الذي بعد الجسم.

blink = 1
while blink <= 3:
    print("LED blink", blink)
    blink += 1
print("Test finished")

LED blink 1
LED blink 2
LED blink 3
Test finished

قد لا يُنفَّذ الجسم ولا مرة: إذا لم يتحقّق الشرط من البداية ننتقل مباشرة إلى ما بعد الحلقة.

volts = 3.0
while volts > 5:
    print("Too high")
    volts -= 1
print("Volts:", volts)

Volts: 3.0

والتحديث لا يعني دائما زيادة واحد. نستطيع أن نزيد بأي خطوة، مثل volts += 3، وأن ننقص في العدّ التنازلي، مثل left -= 1.

الكتابة الخوارزمية والكتابة بالشيفرة – כתיבה אלגוריתמית ומימוש בקוד:

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

ننتبه إلى الفرق في السطر الأخير: في الكلام نقول «حتى» ونذكر متى نتوقف، أما while فيسأل متى نستمر. سنعود إلى هذه الترجمة في البند 4.5.

n = 1
while n <= 3:
    n += 1
    print("Sample", n)

Sample 2
Sample 3
Sample 4

وسطر واحد خارج الإزاحة يخرج من الجسم. الأمر print هنا لا يتكرر، ويُنفَّذ مرة واحدة بعد انتهاء الحلقة:

n = 1
while n <= 3:
    n += 1
print("Sample", n)

Sample 4

n = 1
total = 0
while n < 4:
    total += n
    n += 1
print(n, total)

4.3 مصفاة المُدخَلات العنيدة – מסננת קלט עקשנית (do while)

في البند 3.10 كتبنا مصفاة مُدخَلات تفحص القيمة مرة واحدة ثم تستسلم: إذا كانت القيمة خاطئة طبعنا رسالة وانتهى كل شيء. الآن نستطيع أن نفعل ما يفعله كل جهاز جيد: نسأل مرة بعد مرة حتى يصل مُدخَل صحيح.

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

الطريقة الأولى: قراءة قبل الحلقة وقراءة داخلها:

نقرأ مرة قبل الحلقة، فيكون عند الشرط ما يفحصه. وشرط الحلقة يصف القيمة غير الصالحة:

adc = int(input("ADC (0-1023): "))
while adc < 0 or adc > 1023:
    print("Out of range, try again")
    adc = int(input("ADC (0-1023): "))
print("Accepted:", adc)

ADC (0-1023): 1500
Out of range, try again
ADC (0-1023): -4
Out of range, try again
ADC (0-1023): 512
Accepted: 512

الطريقة الثانية: حلقة بشرط True وخروج بالأمر break:

الشرط True يتحقّق دائما، فنقرأ مرة واحدة داخل الجسم. والأمر break يخرج من الحلقة فورا، وسنتعرف إليه بالتفصيل في البند 4.7. الشرط هنا يصف القيمة الصالحة، وهو عكس شرط الطريقة الأولى:

while True:
    adc = int(input("ADC (0-1023): "))
    if 0 <= adc <= 1023:
        break
    print("Out of range, try again")
print("Accepted:", adc)

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

adc = int(input("ADC (0-1023): "))
if adc < 0 or adc > 1023:
    adc = int(input("ADC (0-1023): "))
print("Accepted:", adc)

ADC (0-1023): 1500
ADC (0-1023): 2000
Accepted: 2000

4.4 قراءة كمية غير معروفة من المعطيات – קליטת כמות לא ידועה של נתונים (תבנית קלט עם זקיף)

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

total = 0
watts = float(input("Load W (0 stops): "))
while watts != 0:
    total += watts
    watts = float(input("Load W (0 stops): "))
print("Total:", total, "W")

Load W (0 stops): 60
Load W (0 stops): 100
Load W (0 stops): 25
Load W (0 stops): 0
Total: 185.0 W

وبالطريقة الثانية من البند السابق نكتب أمر قراءة واحدا: نبدأ الجسم بالقراءة، ثم نفحص قيمة التوقّف ونخرج بالأمر break، ثم نجمع. الفحص يأتي قبل أي حساب.

total = 0
pulses = 1
while pulses != -1:
    pulses = int(input("Pulses (-1 stops): "))
    total += pulses
print("Total:", total)

Pulses (-1 stops): 10
Pulses (-1 stops): 20
Pulses (-1 stops): -1
Total: 29

قيمة التوقّف قد تكون جملة نصية أيضا. نقرأ أسماء قطع إلكترونية حتى الكلمة end، ولا نحوّل المُدخَل إلى عدد:

count = 0
part = input("Part (end stops): ")
while part != "end":
    count += 1
    print("Stored:", part)
    part = input("Part (end stops): ")
print("Parts:", count)

Part (end stops): LM358
Stored: LM358
Part (end stops): 7805
Stored: 7805
Part (end stops): end
Parts: 2

x = int(input("x: "))
y = 0
while x != 0:
    y += x * 2
    x = int(input("x: "))
print(y)

4.5 ترجمة شرط الإنهاء إلى شرط الحلقة – תרגום תנאי סיום לתנאי הלולאה

السؤال في الامتحان وفي الحياة يصف عادة متى نتوقف: «توقف عندما يصل المجموع إلى كذا، أو بعد كذا قراءة». أما while فيحتاج إلى متى نستمر. لذلك نترجم:

العمود الثالث في السطرين الأخيرين هو ما نعرفه من الأنظمة الرقمية باسم قانوني دي مورغان (חוקי דה-מורגן): عندما ننفي شرطا مركبا، ننفي كل طرف فيه، ونبدّل and بـor والعكس. نفحص ذلك لكل القيم الممكنة:

العمودان الثالث والرابع متطابقان، وكذلك الخامس والسادس.

total = 0
packets = 0
while total < 256 and packets < 5:
    size = int(input("Packet bytes: "))
    total += size
    packets += 1
print("Bytes:", total)
print("Packets:", packets)

Packet bytes: 100
Packet bytes: 120
Packet bytes: 90
Bytes: 310
Packets: 3

وإذا صعبت علينا الترجمة، نستطيع أن نكتب النفي كما هو بالمعامل not حول شرط الإنهاء: while not (total >= 256 or packets >= 5):. الحساب نفسه، والنتيجة نفسها.

وهذا الخطأ أخطر في صورة أخرى. نريد مصفاة تقبل الوضع 1 أو 2، فنكتب while mode != 1 or mode != 2:. هذه الحلقة لا تنتهي أبدا: كل عدد يختلف عن 1 أو يختلف عن 2، فالشرط يتحقّق دائما حتى عندما يكتب المستخدم قيمة صحيحة. نعود إلى القاعدة: نتوقف عندما mode == 1 or mode == 2، فنكتب while mode != 1 and mode != 2:.

code = int(input("Code: "))
tries = 1
while code != 4071 and tries < 3:
    code = int(input("Code: "))
    tries += 1
if code == 4071:
    print("Unlocked")
else:
    print("Locked")

Code: 1111
Code: 4071
Unlocked

4.6 مهام حسابية نموذجية – משימות חישוב טיפוסיות

معظم الحلقات في البرامج تفعل واحدا من أشياء قليلة: تعدّ، أو تجمع، أو تبحث عن الأكبر والأصغر. نتعلم كل واحد منها كنمط جاهز، ثم نمزجها. وفي كل نمط نسأل سؤالين: ما القيمة الأولى قبل الحلقة، وماذا يحدث في كل دورة؟

العدّاد – מונה:

value = int(input("Largest value: "))
bits = 0
while value > 0:
    value = value // 2
    bits += 1
print("Bits needed:", bits)

Largest value: 1023
Bits needed: 10

العدّاد مع شرط – מונה עם תנאי:

العدّاد مع شرط لا يزيد في كل دورة، بل فقط عندما يتحقّق الشرط. مكانه هو if داخل جسم الحلقة:

limit = 10
over = 0
amps = float(input("Current (-1 stops): "))
while amps != -1:
    if amps > limit:
        over += 1
    amps = float(input("Current (-1 stops): "))
print("Over the limit:", over)

Current (-1 stops): 8.5
Current (-1 stops): 12
Current (-1 stops): 10.4
Current (-1 stops): -1
Over the limit: 2

المُجمِّع – צובר:

رأينا المُجمِّع في البند 4.4، حين جمعنا قدرات الأجهزة بالأمر total += watts.

الفرق بين العدّاد والمُجمِّع بسيط: العدّاد يضيف واحدا، والمُجمِّع يضيف القيمة نفسها. وهناك مُجمِّع يضرب بدل أن يجمع، وعندها لا يصح أن يبدأ من الصفر:

gain = 1
stage = float(input("Stage gain (0 stops): "))
while stage != 0:
    gain *= stage
    stage = float(input("Stage gain (0 stops): "))
print("Total gain:", gain)

Stage gain (0 stops): 10
Stage gain (0 stops): 5
Stage gain (0 stops): 0
Total gain: 50.0

المتوسط يحتاج إلى النمطين معا: مُجمِّع يحمل المجموع، وعدّاد يحمل عدد القيم. وبما أن عدد القيم قد يكون صفرا، نفحصه قبل القسمة:

count = 0
total = 0
temp = float(input("Temp (999 stops): "))
while temp != 999:
    count += 1
    total += temp
    temp = float(input("Temp (999 stops): "))
if count > 0:
    print("Average:", round(total / count, 2))
else:
    print("No readings")

Temp (999 stops): 22.5
Temp (999 stops): 24
Temp (999 stops): 19.5
Temp (999 stops): 999
Average: 22.0

القيم القصوى – ערכי קיצון:

v = float(input("Volts (0 stops): "))
high = v
low = v
while v != 0:
    if v > high:
        high = v
    if v < low:
        low = v
    v = float(input("Volts (0 stops): "))
print("Ripple:", round(high - low, 2), "V")

Volts (0 stops): 11.9
Volts (0 stops): 12.3
Volts (0 stops): 11.7
Volts (0 stops): 0
Ripple: 0.6 V

top = 0
temp = int(input("Temp (999 stops): "))
while temp != 999:
    if temp > top:
        top = temp
    temp = int(input("Temp (999 stops): "))
print("Highest:", top)

Temp (999 stops): -7
Temp (999 stops): -3
Temp (999 stops): -12
Temp (999 stops): 999
Highest: 0

الحل هو أن تكون القيمة الأولى قراءة حقيقية: نقرأ أولا، ثم نكتب top = temp قبل الحلقة، فيطبع البرنامج Highest: -3.

المزج بين المهام – שילוב בין המשימות:

hour = 0
total = 0
watts = float(input("Panel W (-1 stops): "))
while watts != -1:
    hour += 1
    total += watts
    if hour == 1 or watts > peak:
        peak = watts
        peak_hour = hour
    watts = float(input("Panel W (-1 stops): "))
if hour > 0:
    print("Average:", round(total / hour, 1), "W")
    print("Peak:", peak, "W at hour", peak_hour)

Panel W (-1 stops): 60
Panel W (-1 stops): 110
Panel W (-1 stops): 135
Panel W (-1 stops): 90
Panel W (-1 stops): -1
Average: 98.8 W
Peak: 135.0 W at hour 3

a = 0
b = 0
x = int(input("x: "))
while x != 0:
    a += 1
    if x > 5:
        b += x
    x = int(input("x: "))
print(a, b)

4.7 الأمران break وcontinue – הפקודות break ו-continue

الأمران يظهران دائما تقريبا داخل if، لأننا نقفز عند حالة خاصة فقط.

cell = 1
while cell <= 6:
    v = float(input("Cell V: "))
    if v < 3.0:
        print("Weak cell:", cell)
        break
    cell += 1
print("Scan finished")

Cell V: 3.7
Cell V: 3.6
Cell V: 2.8
Weak cell: 3
Scan finished

الأمر break يجعل البرنامج أقصر، والشرط المركب يجعل سبب الخروج ظاهرا في رأس الحلقة. وكلاهما مقبول.

total = 0
count = 0
while True:
    adc = int(input("ADC (-1 stops): "))
    if adc == -1:
        break
    if adc > 1023:
        print("Ignored:", adc)
        continue
    total += adc
    count += 1
if count > 0:
    print("Average:", total / count)
else:
    print("No readings")

ADC (-1 stops): 500
ADC (-1 stops): 2000
Ignored: 2000
ADC (-1 stops): 520
ADC (-1 stops): -1
Average: 510.0

ch = 1
while ch <= 4:
    if ch == 3:
        continue
    print("Channel", ch)
    ch += 1

نحدّث العدّاد في أول الجسم، قبل أي قفز:

ch = 0
while ch < 4:
    ch += 1
    if ch == 3:
        continue
    print("Channel", ch)

Channel 1
Channel 2
Channel 4

n = 0
while n < 6:
    n += 1
    if n == 2:
        continue
    if n == 5:
        break
    print(n)
print("end", n)

4.8 التنفيذ اللانهائي – ביצוע אינסופי

البرامج في هذا البند لا تنتهي، ولذلك نعرضها بلا مُخرَج. لكل منها سبب مختلف، ونتعلم أن نبحث عنه:

n = 1
while n <= 3:
    print("Sample", n)

n = 1
while n <= 3:
    print("Sample", n)
n += 1

volts = 12
while volts > 0:
    print(volts)
    volts += 3

x = 0.0
while x != 1.0:
    x += 0.1

البرنامج الأخير يحتاج إلى شرح. بعد عشر دورات نتوقع أن تكون القيمة 1، لكننا تعلمنا في البند 3.3 أن الأعداد العشرية لا تُحفظ بدقة تامة. القيمة تمرّ قريبا جدا من 1 ولا تساويها، ثم تتجاوزها وتبتعد:

x = 0.0
n = 0
while n < 10:
    x += 0.1
    n += 1
print(x)
print(x == 1.0)

0.9999999999999999
False

لا نكتب != في شرط الحلقة مع عدد عشري ناتج عن حساب. نفحص الاقتراب بسماح، أو نعدّ الدورات بعدد صحيح كما في البرنامج أعلاه. الشرط while abs(x - 1.0) > 0.001: ينتهي بعد عشر دورات بالضبط. أما قيمة التوقّف التي نقرؤها من المُدخَل، كما في البند 4.4، فحالة أخرى: لم نحسبها، ولذلك تكون المقارنة بها دقيقة.

حلقة لا نهائية مقصودة:

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

while True:
    adc = read_sensor()
    show_on_display(adc)
    wait_one_second()

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

temp = 20
minutes = 0
while temp < 60 and minutes < 30:
    temp += 6
    minutes += 1
if temp >= 60:
    print("Ready after", minutes, "min")
else:
    print("Heater fault")

Ready after 7 min

k = 10
while k > 0:
    k = k - 4

k = 10
while k != 0:
    k = k - 4

k = 1
while k > 0:
    k = k + 1

4.9 تحليل صحّة البرنامج بجدول المتابعة – ניתוח נכונות בעזרת טבלת מעקב

جدول المتابعة يكشف ما يحدث فعلا، لا ما نظن أنه يحدث. وفي الحلقة نقرأه هكذا: ما قيمة كل متغيّر عند أول فحص للشرط؟ وما قيمته عند آخر دورة؟ وما قيمته بعد الخروج؟ أكثر أخطاء الحلقات تقع في البداية أو في النهاية، أي تكون زيادة دورة أو نقصانها.

count = 1
total = 0
v = int(input("V (-1 stops): "))
while v != -1:
    total += v
    count += 1
    v = int(input("V (-1 stops): "))
print(total / count)

بعد التصحيح ينجح المثال، لكن هذا لا يكفي. نجرب أيضا الحالات الحدّية (מקרי קצה): لا قيم أبدا، أو قيمة واحدة فقط. وهنا يظهر خطأ جديد. إذا كانت أول قيمة هي قيمة التوقّف، تنهار القسمة:

count = 0
total = 0
v = int(input("V (-1 stops): "))
while v != -1:
    total += v
    count += 1
    v = int(input("V (-1 stops): "))
print(total / count)

V (-1 stops): -1
ZeroDivisionError: division by zero

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

if count > 0:
    print(total / count)
else:
    print("No readings")

وهناك خطأ حدّي شائع جدا، هو خطأ الدورة الواحدة. يجب أن تطبع الحلقة التالية ثلاث قراءات، لكن n < 3 يتوقف قبل الثالثة:

n = 1
while n < 3:
    print("Sample", n)
    n += 1
print("n =", n)

Sample 1
Sample 2
n = 3

عند الخروج من حلقة ليس فيها break نعرف دائما شيئا مؤكدا: شرط الحلقة لم يعد يتحقّق. هنا يعني ذلك n >= 3، وهذه طريقة سريعة للفحص: نسأل هل الوضع عند الخروج هو ما أردناه.

النجاعة – יעילות:

target = int(input("Value: "))
guess = 0
steps = 0
while guess < target:
    guess += 1
    steps += 1
print("Found", guess, "in", steps, "steps")

Value: 731
Found 731 in 731 steps

target = int(input("Value: "))
low = 0
high = 1023
steps = 0
while low < high:
    mid = (low + high) // 2
    if mid < target:
        low = mid + 1
    else:
        high = mid
    steps += 1
    print(low, high)
print("Found", low, "in", steps, "steps")

Value: 731
512 1023
512 767
640 767
704 767
704 735
720 735
728 735
728 731
730 731
731 731
Found 731 in 10 steps

4.10 التداخل والمزج بين if وwhile – קינון ושילוב מבני if, while

جسم الحلقة يمكن أن يحتوي أي أمر، وكذلك جسم الشرط. هذا هو التداخل (קינון). وقد استعملنا if داخل while طوال الفصل، ويمكن أيضا أن نضع حلقة في فرع من شرط إذا لم نكن نحتاج إليها إلا في حالة معيّنة. وكل مستوى تداخل يضيف إزاحة.

شروط متسلسلة داخل حلقة:

volts = 12.0
choice = int(input("1 up, 2 down, 0 exit: "))
while choice != 0:
    if choice == 1:
        volts += 0.5
    elif choice == 2:
        volts -= 0.5
    else:
        print("Unknown choice")
    print("Output:", volts, "V")
    choice = int(input("1 up, 2 down, 0 exit: "))
print("Bye")

1 up, 2 down, 0 exit: 1
Output: 12.5 V
1 up, 2 down, 0 exit: 2
Output: 12.0 V
1 up, 2 down, 0 exit: 7
Unknown choice
Output: 12.0 V
1 up, 2 down, 0 exit: 0
Bye

حلقة داخل حلقة:

عندما توضع حلقة داخل حلقة، تُنفَّذ الحلقة الداخلية كلها في كل دورة من دورات الخارجية. تشبه عقربي الساعة: عقرب الدقائق يدور دورة كاملة في كل خطوة من خطوات عقرب الساعات.

v = 3
while v <= 9:
    print(v, "V:", end=" ")
    r = 100
    while r <= 300:
        print(round(v / r * 1000, 1), end=" ")
        r += 100
    print()
    v += 3

3 V: 30.0 15.0 10.0 
6 V: 60.0 30.0 20.0 
9 V: 90.0 45.0 30.0 

نتابع حلقتين متداخلتين. هنا حدّ الحلقة الداخلية يتعلق بعدّاد الخارجية، لذلك لا تُنفَّذ الداخلية في الدورة الأولى، وتُنفَّذ مرة في الثانية:

row = 1
while row <= 2:
    col = 1
    while col < row:
        print(row, col)
        col += 1
    row += 1

a = 1
while a <= 3:
    b = a
    while b <= 3:
        print(a * b, end=" ")
        b += 1
    print()
    a += 1

key_row = 2
key_col = 2
found = False
row = 1
while row <= 4 and not found:
    col = 1
    while col <= 3 and not found:
        print("Testing", row, col)
        if row == key_row and col == key_col:
            found = True
        col += 1
    row += 1
print("Key found:", found)

Testing 1 1
Testing 1 2
Testing 1 3
Testing 2 1
Testing 2 2
Key found: True

step = 5 / 1023
limit = 11.8
count = 0
total = 0
below = 0
adc = int(input("ADC battery (-1 stops): "))
while adc != -1:
    volts = adc * step * 4
    count += 1
    total += volts
    if count == 1 or volts > top:
        top = volts
    if count == 1 or volts < bottom:
        bottom = volts
    if volts < limit:
        below += 1
    adc = int(input("ADC battery (-1 stops): "))
if count > 0:
    print("Samples:", count)
    print("Average:", round(total / count, 2), "V")
    print("Min:", round(bottom, 2), "V")
    print("Max:", round(top, 2), "V")
    print("Below limit:", below)
else:
    print("No samples")

ADC battery (-1 stops): 620
ADC battery (-1 stops): 633
ADC battery (-1 stops): 590
ADC battery (-1 stops): 578
ADC battery (-1 stops): -1
Samples: 4
Average: 11.83 V
Min: 11.3 V
Max: 12.38 V
Below limit: 2

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

• الحلقة تحتاج إلى تهيئة وشرط وتحديث. والشرط يُفحص قبل كل دورة، وقد لا يُنفَّذ الجسم أبدا.
• في بايثون لا يوجد do while. نكتب المصفاة العنيدة بقراءة مزدوجة أو بالشكل while True مع break.
• مع قيمة التوقّف نقرأ قبل الحلقة وفي آخر الجسم، فلا تدخل هذه القيمة في الحساب.
• شرط الحلقة هو نفي شرط الإنهاء: نقلب كل مقارنة، ونبدّل or بـand.
• العدّاد والمُجمِّع يبدآن من الصفر، ومُجمِّع الضرب من الواحد، والقيمة القصوى من أول قراءة حقيقية.
• جدول المتابعة والحالات الحدّية يكشفان أخطاء الحلقات، وعدد الدورات مقياس بسيط للنجاعة.
• في الحلقتين المتداخلتين تكون تهيئة الداخلية داخل الخارجية، وbreak يخرج من الداخلية فقط.

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

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

duty = int(input("Duty (0-100): "))
while duty < 0 or duty > 100:
    duty = int(input("Duty (0-100): "))
print("Duty:", duty)

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

k = 2
s = 0
while k < 10:
    s += k
    k = k + 3
print(k, s)

ch = int(input("Channel (1-8): "))
while ch < 1 or ch > 8:
    print("No such channel")
    ch = int(input("Channel (1-8): "))
print("Reading channel", ch)

n = 1
while n <= 4
print(n * 5)
n =+ 1

n = 1
while n <= 4:
    print(n * 5)
    n += 1

x = int(input("x: "))
n = 0
while x > 1:
    x = x // 3
    n += 1
print(x, n)

inverse = 0
r = float(input("R (0 stops): "))
while r != 0:
    inverse += 1 / r
    r = float(input("R (0 stops): "))
if inverse > 0:
    print("R total:", round(1 / inverse, 2))

good = 0
count = 0
v = float(input("LED V (0 stops): "))
while v != 0:
    count += 1
    if 1.8 <= v <= 2.2:
        good += 1
    v = float(input("LED V (0 stops): "))
if count > 0:
    print("Good:", good)
    print("Percent:", round(good * 100 / count, 1))

capacity = 100
years = 0
while capacity >= 80:
    capacity = capacity * 0.97
    years += 1
print("Years:", years)
print("Capacity:", round(capacity, 1))

run = 0
best = 0
t = int(input("Temp (999 stops): "))
while t != 999:
    if t > 40:
        run += 1
        if run > best:
            best = run
    else:
        run = 0
    t = int(input("Temp (999 stops): "))
print("Longest hot run:", best)

a = int(input("LED A period: "))
b = int(input("LED B period: "))
t = a
while t % b != 0:
    t += a
print("Together after:", t)

goal = 5
best_err = 12
r1 = 100
while r1 <= 1000:
    r2 = 100
    while r2 <= 1000:
        vout = 12 * r2 / (r1 + r2)
        err = abs(vout - goal)
        if err < best_err:
            best_err = err
            best1 = r1
            best2 = r2
        r2 += 100
    r1 += 100
print("R1 =", best1, "R2 =", best2)
print("Error:", round(best_err, 3), "V")

value = int(input("Byte (-1 stops): "))
while value != -1:
    ones = 0
    rest = value
    while rest > 0:
        ones += rest % 2
        rest = rest // 2
    print(value, "ones:", ones, "parity:", ones % 2)
    value = int(input("Byte (-1 stops): "))

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

بجروت 2024 السؤال 10 — قمصان وجرزايات

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

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

نبدأ بالترجمة: نتوقف عندما يختلف العدد عن 1 و2، أي نستمر ما دام يساوي 1 أو 2. العدد غير القانوني هو قيمة توقّف، لكن كل عدد آخر يصلح لذلك، ولهذا نكتب الشرط على القيم الصالحة. والعددان عدّادان مع شرط، أما المبلغ فنحسبه بعد الحلقة. نكتب البرنامج ونجرّبه على طلبات من عندنا:

shirts = 0
sweaters = 0
choice = int(input("1 shirt, 2 sweater: "))
while choice == 1 or choice == 2:
    if choice == 1:
        shirts += 1
    else:
        sweaters += 1
    choice = int(input("1 shirt, 2 sweater: "))
total = shirts * 30 + sweaters * 50
print("Shirts:", shirts)
print("Sweaters:", sweaters)
print("Total:", total)

1 shirt, 2 sweater: 1
1 shirt, 2 sweater: 2
1 shirt, 2 sweater: 1
1 shirt, 2 sweater: 1
1 shirt, 2 sweater: 2
1 shirt, 2 sweater: 7
Shirts: 3
Sweaters: 2
Total: 190

الأسماء shirts وsweaters بالإنجليزية كما تعوّدنا. ونفحص أيضا الحالة الحدّية: عدد غير قانوني من البداية، فيطبع البرنامج في السطر الأخير Total: 0.

بجروت 2023 السؤال 9 — تبرّعات لحملة انتخابية

البند	المطلوب	الإجابة
السؤال كله	نقرأ رقم المرشّح ومبلغ التبرّع حتى يتحقّق شرط التوقف، ثم نطبع مجموع كل مرشّح، عدد المتبرّعين وأعلى تبرّع لكل مرشّح.	في الأسفل

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

شرط الإنهاء مركب: يصل المجموع الكلي إلى مليون أو يصل عدد المتبرّعين إلى ألف، فنترجمه كما في البند 4.5:

ونحتاج إلى مُجمِّعين، عدّاد وقيمتين قصويين. يمكن أن تبدأ القيمتان القصويان من الصفر، لأن التبرّع مبلغ موجب، وهذا خلاف ما رأيناه مع الحرارة. ومع ألف تبرّع صغير تتوقف الحلقة بسبب عدد المتبرّعين، ويطبع البرنامج Donors: 1000. ونشغّله الآن على المثال الذي في نص السؤال:

sum1 = 0
sum2 = 0
max1 = 0
max2 = 0
donors = 0
while sum1 + sum2 < 1000000 and donors < 1000:
    candidate = int(input("Candidate: "))
    amount = float(input("Amount: "))
    donors += 1
    if candidate == 1:
        sum1 += amount
        if amount > max1:
            max1 = amount
    else:
        sum2 += amount
        if amount > max2:
            max2 = amount
print("Candidate 1 sum:", sum1)
print("Candidate 2 sum:", sum2)
print("Donors:", donors)
print("Max Donation for Candidate 1:", max1)
print("Max Donation for Candidate 2:", max2)

Candidate: 1
Amount: 200000
Candidate: 2
Amount: 300000
Candidate: 1
Amount: 100000
Candidate: 1
Amount: 100000
Candidate: 2
Amount: 200000
Candidate: 1
Amount: 150000
Candidate 1 sum: 550000.0
Candidate 2 sum: 500000.0
Donors: 6
Max Donation for Candidate 1: 200000.0
Max Donation for Candidate 2: 300000.0

الأعداد هي نفسها التي في السؤال. الفرق الوحيد هو .0 في نهايتها، لأن المبلغ عدد حقيقي حسب نص السؤال، فقرأناه بالدالة float. وتتوقف الحلقة بعد المتبرّع السادس، حين يصبح المجموع 1050000.