מושגי יסוד בתכנות

2.1 כתיבת אלגוריתם מילולי

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

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

2.2 משתנה

volts = 12
current = 0.5
print(volts)
print(current)

12
0.5

בוחרים למשתנה שם שמעיד על משמעותו: current ברור יותר מ-c. ולשמות יש כללים:

• השם מורכב מאותיות אנגליות, ספרות והסימן _, ואינו מתחיל בספרה.
• הוא לא יכול להיות מילה שמורה בשפה, כמו if או else.
• אותיות גדולות וקטנות נבדלות: Volts ו-volts הם שני משתנים שונים.

2volts = 12

SyntaxError: invalid decimal literal

Volts = 12
print(volts)

NameError: name 'volts' is not defined

2.3 מחלקה, תכונות ופעולות

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

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

label = "solar panel"
print(label.upper())
print(label.count("a"))
reading = 12.0
print(reading.is_integer())
print(reading.real)

SOLAR PANEL
2
True
12.0

כך עבדנו בפרק הראשון עם המחלקה המוכנה Turtle: יצרנו עצם ונתנו לו פקודות. כתיבת מחלקות חדשות בעצמנו נלמד בפרק 8.

import turtle
pen = turtle.Turtle()
pen.forward(100)
print(pen.position())

2.4 טיפוסי נתונים בסיסיים

הטיפוס של ערך קובע מה אפשר לעשות בו: מספרים מחברים, ומחרוזות משרשרים. טיפוס הנתונים הוא המחלקה שהערך שייך אליה.

samples = 250
volts = 11.7
device = "fan"
running = True
print(type(samples))
print(type(volts))
print(type(device))
print(type(running))

<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>

המספר 3.0 הוא מטיפוס float אף שערכו שלם, כי יש בו נקודה. והטקסט "12" הוא מטיפוס str אף שתוויו ספרות, כי הוא בין מירכאות.

2.5 תחומי הערכים וגודלם בזיכרון

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

import sys
print(2 ** 100)
print(sys.float_info.max)
print(sys.float_info.min)
print(sys.float_info.dig)
print(sys.int_info.bits_per_digit)
print(sys.float_info.max * 10)

1267650600228229401496703205376
1.7976931348623157e+308
2.2250738585072014e-308
15
30
inf

• למספר השלם int בפייתון אין גבול עליון מלבד זיכרון המחשב, וזה מה שמראה השורה הראשונה בפלט. התכונה bits_per_digit היא מספר הסיביות בכל חלק מחלקי האחסון שלו.
• למספר העשרוני float יש תחום מוגבל: float_info.max הוא המספר הגדול ביותר, float_info.min הוא המספר החיובי הקטן ביותר בדיוק מלא, ו-float_info.dig הוא מספר הספרות העשרוניות שאפשר לסמוך עליהן.
• מה שחורג מן התחום הופך ל-inf, כלומר אינסוף, כמו בשורה האחרונה.

הפעולה sys.getsizeof נותנת את מספר הבתים שהערך תופס בזיכרון:

import sys
print(sys.getsizeof(5))
print(sys.getsizeof(2 ** 100))
print(sys.getsizeof(1.5))
print(sys.getsizeof("abc"))
print(sys.getsizeof(True))

28
40
24
44
28

2.6 פקודות השמה

בפקודת השמה מחושב קודם הערך שמימין לסימן =, ואחר כך הוא מוצב במשתנה שמשמאל לו. לכן count = count + 1 אינה משוואה, אלא פירושה: לוקחים את הערך הנוכחי, מוסיפים לו אחד, ומציבים את התוצאה במקומו.

count = 10
count = count + 1
count += 4
count -= 2
count *= 3
print(count)

39

12 = volts

SyntaxError: cannot assign to literal here. Maybe you meant '==' instead of '='?

אפשר להציב ביותר ממשתנה אחד בפקודה אחת:

v, i = 12, 0.5
print(v, i)
a = b = 0
print(a, b)

12 0.5
0 0

a = 3
b = 8
temp = a
a = b
b = temp
print(a, b)

8 3

a = 3
b = 8
a, b = b, a
print(a, b)

8 3

2.7 הגדרה ואתחול של משתנים

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

print(power)
power = 60

NameError: name 'power' is not defined

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

x = 5
print(type(x))
x = 2.5
print(type(x))
x = "off"
print(type(x))

<class 'int'>
<class 'float'>
<class 'str'>

2.8 אופרטורים חשבוניים

print(7 + 2)
print(7 - 2)
print(7 * 2)
print(7 / 2)
print(8 / 2)
print(2 ** 10)

9
5
14
3.5
4.0
1024

volts = 12
current = 1.5
power = volts * current
hours = 4
energy = power * hours
print(power)
print(energy)

18.0
72.0

a = 9
b = 4
print(a / b)
print(a * b - 1)
print(a ** 2)

2.9 אופרטור מנה ושארית חלוקה

האופרטור // נותן את המנה אחרי השמטת השבר, והאופרטור % נותן את השארית. שני האופרטורים האלה מופיעים כמעט בכל בחינה. ואם אחד המספרים עשרוני, גם התוצאה עשרונית, כמו בשתי השורות האחרונות בפלט של התוכנית הבאה.

print(17 / 5)
print(17 // 5)
print(17 % 5)
print(17.5 // 5)
print(17.5 % 5)

3.4
3
2
3.0
2.5

seconds = 7384
hours = seconds // 3600
left = seconds % 3600
minutes = left // 60
secs = left % 60
print(hours, minutes, secs)

2 3 4

data = 1000
size = 64
full = data // size
rest = data % size
print(full, rest)

15 40

print(-7 // 2)
print(-7 % 2)
print(int(-7 / 2))

-4
1
-3

2.10 פעולות מתמטיות בסיסיות

print(pow(2, 8))
print(max(4.1, 3.9, 5.0))
print(min(4.1, 3.9, 5.0))
print(abs(-12.5))
print(round(3.14159, 2))
print(round(3.7))
print(sum([12, 11.5, 12.5]))
print(divmod(17, 5))

256
5.0
3.9
12.5
3.14
4
36.0
(3, 2)

הסוגריים המרובעים ב-sum יוצרים רשימת ערכים, ונכיר אותה בפרק 6. והסוגריים העגולים בתוצאה של divmod מאגדים שני ערכים יחד.

print(round(2.5))
print(round(3.5))
print(round(2.675, 2))

2
4
2.67

a = 11.8
b = 12.4
c = 12.0
high = max(a, b, c)
low = min(a, b, c)
print(round(high - low, 2))
print(round(sum([a, b, c]) / 3, 2))

0.6
12.07

המודול random נותן ערכים אקראיים, והוא מועיל כדי לדמות חיישן לפני שיש לנו אחד ביד. הפקודה randint נותנת מספר שלם בתחום, כולל הקצוות, הפקודה random() נותנת מספר עשרוני בין 0 ל-1, והפקודה uniform מספר עשרוני בתחום:

import random
random.seed(7)
print(random.randint(1, 6))
print(random.randint(1, 6))
print(round(random.random(), 3))
print(round(random.uniform(11.5, 12.5), 2))

3
2
0.395
11.55

2.11 ביטויים חשבוניים וסדר קדימויות

print(2 + 3 * 4)
print((2 + 3) * 4)
print(2 ** 3 ** 2)
print(-2 ** 2)
print(20 / 2 * 5)

14
20
512
-4
50.0

a = 10
b = 20
print(a + b / 2)
print((a + b) / 2)

20.0
15.0

r1 = 100
r2 = 300
total = r1 * r2 / (r1 + r2)
print(total)

75.0

2.12 המרות בין טיפוסי הנתונים

הפעולות int, float, str ו-bool ממירות ערך לטיפוס שנושא את שמן:

print(int(3.9))
print(int(-3.9))
print(int("42"))
print(float(7))
print(float("3.5"))
print(str(12.5))
print(bool(0))
print(bool(0.5))
print(bool(""))
print(bool("0"))
print(int(True))

3
-3
42
7.0
3.5
12.5
False
True
False
True
1

• int משמיט את השבר ואינו מעגל: int(3.9) נותן 3.
• bool נותן False לכל אפס ולכל מחרוזת ריקה, ו-True לכל ערך אחר מבין הטיפוסים שלמדנו עד כה, אפילו למחרוזת "0".

המרה יכולה להיכשל. מחרוזת עם נקודה אינה מומרת ישירות ל-int, ואי אפשר לשרשר מספר למחרוזת בלי המרה:

print(int("3.5"))

ValueError: invalid literal for int() with base 10: '3.5'

print("Volts: " + 12)

TypeError: can only concatenate str (not "int") to str

הסימן + הוא חיבור בין מספרים ושרשור בין מחרוזות, והסימן * הוא כפל בין מספרים וחזרה על מחרוזת:

print("Volts: " + str(12))
print("12" + "3")
print(12 + 3)
print("ab" * 3)

Volts: 12
123
15
ababab

2.13 הצגת ערכים בצורות שונות

אפשר לכתוב אותו מספר בכמה שיטות ספירה, כמו שלמדנו במערכות ספרתיות. והמחשב שומר כל תו כמספר.

print(bin(13))
print(hex(255))
print(0b1101)
print(0xFF)
print(int("1101", 2))
print(int("FF", 16))
print(ord("V"))
print(chr(86))
print(bin(ord("V")))
print(hex(ord("V")))

0b1101
0xff
13
255
13
255
86
V
0b1010110
0x56

שלוש השורות האחרונות מראות מה קורה באמת כששולחים תו כמו V לארדואינו, כפי שנעשה בפרק 10: לא נשלחת אות, אלא בית שערכו 0x56.

2.14 שגיאות לוגיות, שגיאות תחביר, שגיאות בזמן ריצה

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

print("start")
print("end"

SyntaxError: '(' was never closed

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

print("start")
r = 0
print(12 / r)
print("end")

start
ZeroDivisionError: division by zero

print("start")
print(volt)

start
NameError: name 'volt' is not defined

השגיאה הלוגית היא המסוכנת ביותר: התוכנית הבאה רצה בלי תלונה, אבל היא כופלת במקום לחלק בחוק אום. הזרם הנכון הוא 3 A:

volts = 12
resistance = 4
current = volts * resistance
print(current)

48

2.15 פעולות קלט/פלט ושרשור מחרוזות

הפקודה print מדפיסה ערכים, מפרידה ביניהם ברווח ועוברת לשורה חדשה. הפרמטר sep משנה את המפריד, והפרמטר end משנה את מה שבא בסוף. שרשור מחרוזות בסימן + אינו מוסיף רווח, ודורש המרה של מספרים:

volts = 12
print("Volts:", volts)
print("a", "b", "c", sep="-")
print("no new line", end=" | ")
print("same line")
print()
print("Volts: " + str(volts))

Volts: 12
a-b-c
no new line | same line

Volts: 12

הפקודה input מציגה הודעה, מחכה למה שהמשתמש מקליד, ומחזירה אותו תמיד כמחרוזת:

name = input("Sensor name: ")
print("Reading", name)

Sensor name: Temp-1
Reading Temp-1

a = input("a: ")
b = input("b: ")
print(a + b)
print(int(a) + int(b))

a: 12
b: 30
1230
42

לכן ממירים מיד בקריאה: int(input()) או float(input()). נחזור עכשיו לאלגוריתם הסוללה מסעיף 2.1, וכל צעד בו הופך לפקודה:

capacity = float(input("Capacity (Ah): "))
load = float(input("Load (A): "))
total = round(capacity / load * 60)
hours = total // 60
minutes = total % 60
print("Runs for", hours, "h", minutes, "min")

Capacity (Ah): 20
Load (A): 3
Runs for 6 h 40 min

2.16 ביצוע טבלת מעקב

טבלת מעקב מראה מה קורה בתוכנית פקודה אחר פקודה: עמודה לכל משתנה ועמודה לפלט. תא ריק פירושו שהערך לא השתנה. בפרק הבא תתווסף עמודה לכל תנאי.

volts = 12
current = 2
power = volts * current
volts = volts - 1
print(volts, power)

seconds = int(input("Seconds: "))
minutes = seconds // 60
seconds = seconds % 60
print(minutes, seconds)

x = 7
y = x % 3
x = x // 2 + y
y = y * x
print(x, y)

adc_batt = int(input("ADC battery: "))
adc_temp = int(input("ADC temp: "))
step = 5 / 1023
battery = adc_batt * step * 4
temp = adc_temp * step * 100
print("Battery:", round(battery, 2), "V")
print("Temp:", round(temp, 1), "C")

ADC battery: 620
ADC temp: 82
Battery: 12.12 V
Temp: 40.1 C

עיקרי הפרק:

• כותבים את האלגוריתם קודם במילים, ואז מתרגמים אותו.
• משתנה שומר ערך אחד, והשמה מחשבת קודם את הצד הימני ואז מציבה את התוצאה בצד השמאלי.
• החילוק / נותן מספר עשרוני, ו-// ו-% נותנים את המנה ואת השארית.
• הפקודה input מחזירה תמיד מחרוזת, וממירים אותה לפני שמחשבים בה.
• שגיאה לוגית אינה נותנת הודעה, ולכן בודקים כל תוכנית על דוגמה שתוצאתה ידועה.

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

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

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

a = 14
b = 4
print(a // b, a % b)
print(a / b)
print(a ** 2 - b)
print(type(a / 2))

volts = float(input("V: "))
print("Half:", volts / 2)

a = input("a: ")
b = input("b: ")
print("Sum: " + a + b)

a = int(input("a: "))
b = int(input("b: "))
print("Sum: " + str(a + b))

amps = float(input("Current (A): "))
hours = float(input("Hours: "))
print("Charge:", amps * hours, "Ah")

f = float(input("Fahrenheit: "))
c = (f - 32) * 5 / 9
print(round(c, 1))

vin = float(input("Vin: "))
r1 = float(input("R1: "))
r2 = float(input("R2: "))
vout = vin * r2 / (r1 + r2)
print("Vout:", round(vout, 2))

parts = int(input("Parts: "))
reel = int(input("Parts per reel: "))
print("Full reels:", parts // reel)
print("Left over:", parts % reel)

value = int(input("Value: "))
print(bin(value))
print(hex(value))
print(value // 16, value % 16)

adc = int(input("ADC: "))
percent = adc * 100 / 1023
print(round(percent, 1), "%")

import random
random.seed(3)
reading = 20 + random.uniform(-0.5, 0.5)
print(round(reading, 2))

bits = int(input("Bits: "))
print("Bytes:", bits // 8)
print("Extra bits:", bits % 8)
print("Bytes needed:", (bits + 7) // 8)

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

בגרות 2026 שאלה 9 — ספרות של מספר תלת-ספרתי

סעיף	המבוקש	תשובה
(ג)	סכום הספרות של מספר חיובי תלת-ספרתי.	למטה
(א) , (ב)	נשענים על לולאות, רשימות ופעולות.	בפרק 7

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

עוד לא למדנו לכתוב פעולות, ולכן נחשב ישירות עבור מספר אחד. num // 100 נותן את ספרת המאות, num % 10 נותן את ספרת האחדות, ו-(num // 10) % 10 נותן את ספרת העשרות:

num = 472
hundreds = num // 100
tens = (num // 10) % 10
ones = num % 10
print(hundreds, tens, ones)
print(hundreds + tens + ones)

4 7 2
13