ביצוע מותנה

3.1 הטיפוס הבוליאני (bool)

כל החלטה בתוכנית מתחילה בשאלה שתשובתה כן או לא: האם הדלת פתוחה? האם המתח גבוה מן הגבול? לתשובות מהסוג הזה יש טיפוס נתונים מיוחד.

lamp_on = True
door_open = False
print(lamp_on)
print(door_open)
print(type(lamp_on))

True
False
<class 'bool'>

הערכים True ו-False אינם מחרוזות, ולכן לא מקיפים אותם במירכאות. והאות הראשונה בהם גדולה תמיד.

lamp_on = true

NameError: name 'true' is not defined

3.2 אופרטורי השוואה

הדרך העיקרית לקבל ערך בוליאני היא להשוות בין שני ערכים. יש שישה אופרטורי השוואה, והתוצאה של כל אחד מהם היא True או False.

volts = 12
print(volts == 12)
print(volts != 12)
print(volts > 12)
print(volts < 15)
print(volts >= 12)
print(volts <= 9)

True
False
False
True
True
False

volts = 12
if volts = 12:
    print("ok")

SyntaxError: invalid syntax. Maybe you meant '==' or ':=' instead of '='?

ההשוואה מתחשבת גם בטיפוס: המספר 5 והמחרוזת "5" אינם אותו ערך, ואילו המספר השלם 5 והמספר העשרוני 5.0 שווים, כי ערכם המספרי זהה. לכן ממירים למספר את מה שנקרא בפקודה input לפני שמשווים אותו למספר.

print(5 == 5.0)
print(5 == "5")
print("Volt" == "volt")

True
False
False

volts = float(input("Battery voltage: "))
print("Can start:", volts >= 11.8)

Battery voltage: 12.1
Can start: True

a = 7
b = 2
print(a % b == 1)
print(a // b > 3)
print(a / b != 3.5)

3.3 בעייתיות ההשוואה בערכים עשרוניים

מספר עשרוני float נשמר במחשב בשיטה הבינארית, והרבה שברים עשרוניים פשוטים אי אפשר לכתוב בה בדיוק מלא, כמו שאי אפשר לכתוב שליש בדיוק מלא במספרים עשרוניים. לכן מצטברים בחישוב הבדלים קטנים מאוד:

total = 0.1 + 0.2
print(total)
print(total == 0.3)

0.30000000000000004
False

החישוב נכון בקירוב, אבל ההשוואה == דורשת שוויון מוחלט, ולכן התנאי אינו מתקיים. מאותה סיבה != יכול להתקיים במקום שלא ציפינו.

expected = 0.3
measured = 0.1 + 0.2
tolerance = 0.001
print(measured == expected)
print(abs(measured - expected) < tolerance)

False
True

x = 1.1 + 2.2
print(x == 3.3)
print(abs(x - 3.3) < 0.01)

3.4 אופרטורים בוליאניים וטבלאות האמת

החלטה אמיתית תלויה בדרך כלל ביותר משאלה אחת: מפעילים את המנוע אם הדלת סגורה וגם הלחצן לחוץ. מחברים בין תנאים בשלושה אופרטורים בוליאניים:

את תוצאות החישוב של האופרטורים מסכמים בטבלת אמת, אותה טבלה שאנחנו מכירים משערים לוגיים במערכות ספרתיות:

door_open = False
button = True
temp = 72
pressure = 6.5
motor = not door_open and button
alarm = temp > 80 or pressure > 6
print("Motor:", motor)
print("Alarm:", alarm)

Motor: True
Alarm: True

a = True
b = False
print(a and b)
print(a or b)
print(not b)
print(not a or b)

3.5 ביטויים בוליאניים וסדר הפעולות

ביטוי בוליאני יכול להיות פשוט, כמו x > 3, או מורכב מכמה תנאים. כשאין סוגריים, פייתון מחשבת את הביטוי לפי הסדר הבא, מלמעלה למטה:

x > 3 and y < 10 or y == 12

x = 5
y = 12
print(x > 3 and y < 10 or y == 12)
print(x > 3 and (y < 10 or y == 12))

True
True

כדי לבדוק שערך נמצא בתחום, פייתון מאפשרת לכתוב שתי השוואות ברצף, והן אומרות אותו דבר כמו תנאי עם and:

adc = 512
print(0 <= adc <= 1023)
print(adc >= 0 and adc <= 1023)

True
True

mode = 5
print(mode == 3 or 7)
print(mode == 3 or mode == 7)

7
False

ועוד דבר מועיל: פייתון מפסיקה לחשב ברגע שהתוצאה ידועה, וזה נקרא קיצור דרך בחישוב. אם האגף השמאלי של and הוא שקר, האגף הימני אינו מחושב כלל, וכך גם אם האגף השמאלי של or הוא אמת. לכן התוכנית הבאה רצה בלי שגיאה, אף שיש בה חלוקה בהתנגדות אפס:

r = 0
print(r != 0 and 12 / r > 1)

False

a = 4
b = 9
print(a > 5 or b > 5 and a != 4)
print((a > 5 or b > 5) and a != 4)
print(not a > 5 and b > 5)

3.6 ביצוע מותנה: if

הפקודה if מבצעת קבוצת פקודות רק כשתנאי מתקיים. כותבים אותה כך:

if condition:
    statement
    statement
next_statement

• אחרי התנאי באות נקודתיים :, ובלעדיהן התוכנית אינה רצה.
• הפקודות ששייכות לתנאי, כלומר גוף התנאי, מוזחות פנימה ארבעה רווחים. ההזחה היא שקובעת מה שייך לתנאי; אין סוגריים.
• הפקודה הבאה, בלי הזחה, אינה שייכת לתנאי ומתבצעת בכל מקרה.

temp = int(input("Temperature: "))
if temp > 40:
    print("Too hot!")
    print("Turn the fan on")
print("Check finished")

Temperature: 47
Too hot!
Turn the fan on
Check finished

שורה אחת שמזיחים או לא מזיחים משנה את משמעות התוכנית. בתוכנית הבאה הטמפרטורה נמוכה, ובכל זאת השורה האחרונה מודפסת, כי היא מחוץ לגוף התנאי:

temp = 30
if temp > 40:
    print("Too hot!")
print("Turn the fan on")

Turn the fan on

ואם שוכחים את ההזחה לגמרי, התוכנית אינה מתחילה כלל:

temp = 47
if temp > 40:
print("Too hot!")

IndentationError: expected an indented block after 'if' statement on line 2

טבלת מעקב:

טבלת מעקב היא הכלי העיקרי להבנת תוכנית ולבדיקתה, והיא נדרשת בבחינת הבגרות. פותחים בה עמודה לכל משתנה, עמודה לכל תנאי ועמודה לפלט, וכותבים שורה לכל פקודה שמתבצעת. תא ריק פירושו שהערך לא השתנה. פקודה שאינה מתבצעת אינה מופיעה בטבלה.

a = 3
b = 8
if b > a:
    a = a + b
    b = 0
if a > 10:
    b = 1
print(a, b)

3.7 ביצוע מותנה: if..else

כשרוצים לבצע הוראה אחת כשהתנאי מתקיים והוראה אחרת כשאינו מתקיים, מוסיפים else. אז מתבצע בדיוק אחד משני הגופים. אחרי else אין תנאי, אלא נקודתיים בלבד.

presses = int(input("Button presses: "))
if presses % 2 == 1:
    print("Lamp ON")
else:
    print("Lamp OFF")
print("done")

Button presses: 14
Lamp OFF
done

solar = float(input("Solar panel V: "))
battery = float(input("Battery V: "))
if solar > battery:
    source = "solar"
else:
    source = "battery"
print("Load runs from:", source)

Solar panel V: 11.2
Battery V: 12.4
Load runs from: battery

x = int(input("x: "))
if x % 3 == 0:
    x = x // 3
else:
    x = x + 1
print(x)

3.8 שרשרת תנאים: elif

כשיש יותר משני מקרים מוסיפים elif, שהוא קיצור של "אחרת, אם". התנאים נבדקים מלמעלה למטה, ובתנאי הראשון שמתקיים מתבצע הגוף שלו ומדלגים על שאר השרשרת. החלק else בסוף הוא רשות, והוא מתבצע אם אף תנאי לא התקיים.

volts = float(input("Battery voltage: "))
if volts >= 12.6:
    print("Full")
elif volts >= 12.0:
    print("Partly charged")
elif volts >= 11.8:
    print("Low")
else:
    print("Empty")

Battery voltage: 12.2
Partly charged

volts = 13.0
if volts >= 11.8:
    print("Low")
elif volts >= 12.6:
    print("Full")

Low

וזה אינו כמו סדרה של פקודות if נפרדות: בפקודות נפרדות כל תנאי נבדק בלי קשר למה שקרה לפניו, ולכן יכול להתבצע יותר מגוף אחד:

temp = 95
if temp >= 90:
    print("Shutdown")
if temp >= 70:
    print("Alarm")
if temp >= 50:
    print("Fan on")

Shutdown
Alarm
Fan on

n = int(input("n: "))
if n > 100:
    print("A")
elif n > 50:
    print("B")
elif n > 10:
    print("C")
else:
    print("D")

3.9 תנאי בתוך תנאי

גוף התנאי יכול להכיל כל פקודה, כולל פקודת if נוספת. זהו קינון תנאים. כל רמת קינון מוסיפה הזחה, ו-else שייך ל-if שנמצא באותה עמודה.

supply = float(input("Supply voltage: "))
if supply > 2:
    resistor = (supply - 2) / 0.02
    if resistor >= 220:
        print("Use", resistor, "ohm")
    else:
        print("Use 220 ohm")
else:
    print("Supply too low")

Supply voltage: 12
Use 500.0 ohm

תנאי שבא מיד אחרי תנאי, בלי שום חישוב ביניהם, אפשר לכתוב בעזרת and, והתוכנית מתקצרת:

if temp > 40:
    if fan_ok:
        print("Fan on")

if temp > 40 and fan_ok:
    print("Fan on")

בתוכנית של הדוגמה הקודמת זה אינו פשוט כל כך, כי בין שני התנאים יש פקודה שמחשבת את ההתנגדות, ולכל תנאי יש ענף else משלו.

a = int(input("a: "))
b = int(input("b: "))
if a > 0:
    if b > 0:
        print("both")
    else:
        print("first")
else:
    if b > 0:
        print("second")
    else:
        print("none")

3.10 תקינות קלט ומסננת קלט פשוטה

תוכנית טובה אינה סומכת על מה שהמשתמש מקליד. מסננת קלט בודקת את הערך לפני השימוש בו, ועוצרת את החישוב אם הוא אינו תקין. בפרק הזה נכתוב אותה בתנאי בלבד; בפרק 4 נלמד את התוכנית לחזור ולשאול עד שמתקבל קלט תקין.

adc = int(input("ADC reading: "))
if 0 <= adc <= 1023:
    if adc >= 512:
        print("Upper half")
    else:
        print("Lower half")
else:
    print("Sensor fault")

ADC reading: 1200
Sensor fault

ויש סכנה גדולה יותר מהדפסת תוצאה שגויה: קלט לא תקין יכול לעצור את התוכנית כולה. זה מה שקורה בחוק אום אם המשתמש מזין התנגדות אפס:

v = 12.0
r = float(input("R: "))
print("I =", v / r)

R: 0
ZeroDivisionError: division by zero

נכניס את החישוב לתוך תנאי, וכך התוכנית מגיעה לחלוקה רק עם ערך תקין:

v = 12.0
r = float(input("R: "))
if r > 0:
    print("I =", v / r)
else:
    print("R must be positive")

R: 0
R must be positive

3.11 משפט בחירה (switch-case): match

כשמשווים משתנה אחד לרשימה של ערכים קבועים, כמו בתפריט, אפשר לכתוב במקום שרשרת elif את הפקודה match. תכנית הלימודים קוראת לה משפט switch-case, כמו בשפות אחרות, והיא קיימת בפייתון מאז גרסה 3.10.

choice = int(input("Choice: "))
match choice:
    case 1:
        print("Start motor")
    case 2:
        print("Stop motor")
    case 3 | 4:
        print("Show status")
    case _:
        print("Unknown choice")

Choice: 4
Show status

battery = float(input("Battery V: "))
temp = float(input("Temperature: "))
if battery < 11.8:
    load = False
else:
    load = True
if temp > 40 and load:
    fan = "ON"
else:
    fan = "OFF"
print("Load on:", load)
print("Fan:", fan)

Battery V: 12.4
Temperature: 46
Load on: True
Fan: ON

עיקרי הפרק:

• תנאי הוא ביטוי שערכו True או False. בונים אותו באופרטורי השוואה ומחברים את חלקיו באופרטורים and, or ו-not.
• הסימן = הוא השמה ושני הסימנים == הם השוואה. מספרים עשרוניים משווים בסבילות, ולא בשוויון מוחלט.
• ההזחה היא שקובעת מה שייך לתנאי. היא חלק מן השפה ואינה קישוט.
• בשרשרת elif מתבצע לכל היותר גוף אחד, ולכן סדר התנאים חשוב.
• בודקים את הקלט לפני שמשתמשים בו, ועוקבים אחר התוכנית בטבלת מעקב לפני ששופטים אותה.

סיכום פקודות הפרק:

מילון מונחים:

שאלות לתרגול:

a = 6
b = 15
print(a > 5 and b < 10)
print(a > 5 or b < 10)
print(not (a == 6))
print(b % a == 3)

x = int(input("x: "))
y = 1
if x > 5:
    y = y + x
if x > 10:
    y = y * 2
else:
    y = y - 1
print(y)

t = 30
if t = 30
print("ok")

t = 30
if t == 30:
    print("ok")

v = float(input("V: "))
if 0 < v <= 5:
    print("Safe")
else:
    print("Unsafe")

t = float(input("Temperature: "))
if t < 0:
    print("Freezing")
elif t < 15:
    print("Cold")
elif t < 30:
    print("Warm")
else:
    print("Hot")

nominal = float(input("Nominal: "))
measured = float(input("Measured: "))
low = nominal * 0.95
high = nominal * 1.05
if low <= measured <= high:
    print("Good resistor")
else:
    print("Reject")

l1 = float(input("L1: "))
l2 = float(input("L2: "))
l3 = float(input("L3: "))
top = l1
name = "L1"
if l2 > top:
    top = l2
    name = "L2"
if l3 > top:
    top = l3
    name = "L3"
print("Highest:", name, top)

a = int(input("a: "))
b = int(input("b: "))
if a > b:
    a = a - b
elif a == b:
    a = 0
else:
    b = b - a
    if b > 3:
        b = b // 2
print(a, b)

v = float(input("V: "))
r = float(input("R: "))
if r > 0:
    print("I =", v / r)
else:
    print("R must be positive")

year = int(input("Year: "))
if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
    print("Leap year")
else:
    print("Common year")

low = 2.0
high = 3.0
v = float(input("V: "))
if v < 0:
    print("Bad reading")
elif v < low:
    print("Below window")
elif v <= high:
    print("Inside window")
else:
    print("Above window")

choice = int(input("Find (1=V, 2=I, 3=R): "))
a = float(input("First value: "))
b = float(input("Second value: "))
match choice:
    case 1:
        print("V =", a * b)
    case 2:
        if b != 0:
            print("I =", a / b)
        else:
            print("Division by zero")
    case 3:
        if b != 0:
            print("R =", a / b)
        else:
            print("Division by zero")
    case _:
        print("Unknown choice")

שאלות בגרות לפרק 3

בגרות 2026 שאלה 10 — כרטיס נסיעה

סעיף	המבוקש	תשובה
(ב)	כתבו תוכנית שמדפיסה את שם בעל הכרטיס שיתרתו גבוהה יותר מבין שני כרטיסים. אם היתרות שוות, היא מדפיסה הודעה מתאימה.	למטה
(א) , (ג)	נשענים על המחלקה TravelCard עצמה.	בפרק 8

הפתרון המלא: fahed-lab.com/exams/electronics-815381/815381/solutions/solution-2026

עוד לא למדנו מחלקות, ולכן נשמור כל שם וכל יתרה במשתנה משלהם. ההיגיון של הסעיף הוא בדיוק אותה שרשרת:

name1 = input("Name 1: ")
balance1 = float(input("Balance 1: "))
name2 = input("Name 2: ")
balance2 = float(input("Balance 2: "))
if balance1 > balance2:
    print(name1)
elif balance2 > balance1:
    print(name2)
else:
    print("Both cards have the same balance.")

Name 1: Dana
Balance 1: 75.5
Name 2: Omar
Balance 2: 40
Dana

התוכנית מדפיסה Both cards have the same balance. כשהיתרות שוות. בפתרון הבחינה עצמו, אחרי שנלמד מחלקות, נכתוב c1.balance במקום balance1, והתנאי יישאר כמו שהוא.