פעולות (פונקציות)

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)

משתנה מקומי נעלם כשהפעולה מסתיימת, ואם מדפיסים אותו אחריה התוכנית נעצרת בשגיאה 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 כנקודת הכניסה לקוד התוכנית

קובץ שכתבנו יכול להיות מיובא לתוכנית אחרת בפקודה 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)

גוף של פעולה לא יכול להיות ריק: אם כותבים את ההגדרה ורוצים לחזור אליה אחר כך, התוכנית נעצרת בשגיאה 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