# דוגמאות פתורות, צעד אחרי צעד: פייתון לבחינה (תשפ"ז)
> לכל נושא שמשרד החינוך הדגיש: הסבר קצר, קוד, **הפלט האמיתי** שלו, ומה קרה בכל שלב. קראו את הקוד ונסו לנחש את הפלט **לפני** שאתם מסתכלים. אחר כך עברו ל[תרגילים](/python-course-hebrew/exam-prep/exercises.html).
>
> **רמות הקושי:** 🟢 בסיסי · 🟡 בינוני · 🔴 מתקדם
---
## 1. פירוק מספר שלם לספרות: `//`, `%` ו‑`**` עם בסיס 10
### דוגמה 1 🟢: מה עושים `% 10` ו‑`// 10`?
ניקח את 4725 ונריץ שלוש פעולות:
```python
num = 4725
print(num % 10) # remainder of dividing by 10
print(num // 10) # whole-number division by 10
print(num // 100 % 10) # drop two digits, then take the last
```
הפלט:
```text
5
472
7
```
**מה קרה כאן?** `% 10` נותן את **הספרה האחרונה**. `// 10` **מוריד** את הספרה האחרונה. והשילוב `// 100 % 10` נותן ספרה מהאמצע: ספרת המאות.
### דוגמה 2 🟡: סכום הספרות, עם טבלת מעקב
התבנית הקבועה: כל עוד המספר גדול מ‑0, לוקחים ספרה ו"מורידים" אותה.
```python
num = 381
total = 0
while num > 0:
digit = num % 10
total += digit
num = num // 10
print(total)
```
הפלט:
```text
12
```
**מה קרה כאן?**
| סיבוב | num בהתחלה | digit | total | num בסוף |
|:-:|:-:|:-:|:-:|:-:|
| 1 | 381 | 1 | 1 | 38 |
| 2 | 38 | 8 | 9 | 3 |
| 3 | 3 | 3 | 12 | 0 |
כש‑num מגיע ל‑0 התנאי `num > 0` הוא False, והלולאה נגמרת. **שימו לב:** בסוף num הוא 0. אם צריך את המספר המקורי, שומרים אותו קודם במשתנה אחר.
---
## 2. לולאות `while` ו‑`for`, לולאות מקוננות וזקיף
### דוגמה 3 🟢: זקיף: קולטים עד שמקלידים -1
לא יודעים מראש כמה מספרים יגיעו, ולכן `while`. שימו לב לשני ה‑`input`:
```python
total = 0
num = int(input("מספר (-1 לסיום): ")) # 1. one input BEFORE the loop
while num != -1: # 2. stop at the sentinel
total += num # 3. work with the number
num = int(input("מספר (-1 לסיום): ")) # 4. the next input, at the END
print("סכום:", total)
```
הקלט: `10` · `20` · `-1`
הפלט:
```text
מספר (-1 לסיום): 10
מספר (-1 לסיום): 20
מספר (-1 לסיום): -1
סכום: 30
```
**מה קרה כאן?** ה‑`input` הראשון נותן ערך לתנאי בפעם הראשונה. ה‑`input` שבסוף הלולאה מביא את המספר הבא. הזקיף (-1) **לא נכנס** לסכום: ברגע שהוא נקלט, התנאי נכשל.
### דוגמה 4 🟡: לולאה מקוננת: מי רץ מתי?
הלולאה הפנימית רצה **מההתחלה ועד הסוף** בכל סיבוב של הלולאה החיצונית:
```python
for i in range(1, 3):
for j in range(1, 4):
print("i =", i, "j =", j)
```
הפלט:
```text
i = 1 j = 1
i = 1 j = 2
i = 1 j = 3
i = 2 j = 1
i = 2 j = 2
i = 2 j = 3
```
**מה קרה כאן?** בסך הכול 2 × 3 = **6** הדפסות. i משתנה רק אחרי ש‑j עבר על כל הערכים שלו.
---
## 3. רשימות: איברים סמוכים ורשימת מונים
### דוגמה 5 🟡: השוואה לשכן
סופרים זוגות סמוכים שווים. הלולאה רצה עד `len(lst) - 1`, כי לאיבר האחרון אין שכן:
```python
lst = [4, 4, 7, 2, 2]
pairs = 0
for i in range(len(lst) - 1):
if lst[i] == lst[i + 1]:
pairs += 1
print(pairs)
```
הפלט:
```text
2
```
**מה קרה כאן?**
| i | lst[i] | lst[i + 1] | שווים? |
|:-:|:-:|:-:|:-:|
| 0 | 4 | 4 | ✓ |
| 1 | 4 | 7 | |
| 2 | 7 | 2 | |
| 3 | 2 | 2 | ✓ |
i עוצר ב‑3. אילו הגיע ל‑4, `lst[5]` היה גורם ל‑`IndexError`.
### דוגמה 6 🟡: רשימת מונים: הערך הופך לאינדקס
סופרים תוצאות של קובייה. `counts[r] += 1`: התוצאה r היא **המיקום** בתוך counts:
```python
rolls = [2, 5, 2, 6, 2]
counts = [0] * 7 # indexes 0..6, index 0 is not used
for r in rolls:
counts[r] += 1
print(counts)
print("התוצאה 2 יצאה", counts[2], "פעמים")
```
הפלט:
```text
[0, 0, 3, 0, 0, 1, 1]
התוצאה 2 יצאה 3 פעמים
```
**מה קרה כאן?** `counts[2]` הוא 3: **המיקום** 2 הוא התוצאה, ו**הערך** 3 הוא כמה פעמים היא יצאה.
---
## 4. מילון (`dict`)
### דוגמה 7 🟢: בונים מילון, צעד אחרי צעד
מתחילים ממילון ריק, מכניסים, משנים וקוראים לפי מפתח:
```python
grades = {} # an empty dictionary
grades["דנה"] = 90 # insert a key and a value
grades["עומר"] = 75
print(grades)
grades["עומר"] = 80 # the same key again = update
print(grades["עומר"]) # access by key
print("לין" in grades) # is the key in the dictionary?
for name, g in grades.items():
print(name, g)
```
הפלט:
```text
{'דנה': 90, 'עומר': 75}
80
False
דנה 90
עומר 80
```
**מה קרה כאן?** מפתח מופיע במילון **פעם אחת** בלבד. כתיבה למפתח שכבר קיים **מחליפה** את הערך שלו.
### דוגמה 8 🟡: ספירה בעזרת מילון
התבנית: אם המפתח כבר קיים, מוסיפים 1. אם לא, מכניסים אותו עם 1:
```python
fruits = ["תפוח", "בננה", "תפוח", "תפוח", "בננה"]
counts = {}
for f in fruits:
if f in counts:
counts[f] += 1
else:
counts[f] = 1
print(counts)
```
הפלט:
```text
{'תפוח': 3, 'בננה': 2}
```
**מה קרה כאן?** בלי ה‑`if`, השורה `counts[f] += 1` על מפתח חדש הייתה נכשלת ב‑`KeyError`.
---
## 5. קבצים (`txt` בלבד): קריאה, כתיבה, `split`
### דוגמה 9 🟢: w, a, r: מה קורה לקובץ?
כותבים, מוסיפים וקוראים, ובודקים מה יש בקובץ אחרי כל שלב:
```python
file = open("log.txt", "w", encoding="utf-8") # "w": a new, empty file
file.write("שורה 1\n")
file.close()
file = open("log.txt", "a", encoding="utf-8") # "a": add at the end
file.write("שורה 2\n")
file.close()
file = open("log.txt", "r", encoding="utf-8") # "r": read
print(file.read())
file.close()
```
הפלט:
```text
שורה 1
שורה 2
```
**מה קרה כאן?** אילו בשלב השני היינו פותחים שוב עם `"w"` במקום `"a"`, "שורה 1" הייתה **נמחקת**.
### דוגמה 10 🟡: split על שורה מקובץ
שורה בקובץ היא מחרוזת אחת. `split("#")` הופך אותה לרשימה, וכל חלק מקבל אינדקס:
הקובץ `one.txt`:
```text
רון#מתמטיקה#45
```
```python
file = open("one.txt", "r", encoding="utf-8")
line = file.readline()
file.close()
data = line.split("#")
print(data)
print(data[0], "|", data[1], "|", int(data[2]) + 10)
```
הפלט:
```text
['רון', 'מתמטיקה', '45\n']
רון | מתמטיקה | 55
```
**מה קרה כאן?** `data[2]` הוא `"45\n"`, טקסט. `int()` הופך אותו למספר (ומתעלם מה‑`\n`), ורק אז אפשר לחשב איתו.
---
## 6. מחרוזות: `len`, `split`, `strip`, `lower`/`upper`, `replace`, `find`, חיתוך
### דוגמה 11 🟢: שרשרת של strip, lower ו‑replace
כל פעולה מחזירה מחרוזת **חדשה**, ולכן אפשר לשרשר אותן:
```python
raw = " Hello World "
print("[" + raw.strip() + "]")
print(raw.strip().lower())
print(raw.strip().lower().replace(" ", "-"))
print(len(raw), len(raw.strip()))
```
הפלט:
```text
[Hello World]
hello world
hello-world
15 11
```
**מה קרה כאן?** המחרוזת המקורית `raw` **לא משתנה**. לכן האורך שלה נשאר 15.
### דוגמה 12 🟡: find וחיתוך
`find` מחזירה **מיקום**, ואיתו חותכים:
```python
date = "14/10/2026"
first = date.find("/")
print(first)
print(date[:first]) # before the first "/"
print(date[first + 1:first + 3])
print(date.find("-")) # not found
```
הפלט:
```text
2
14
10
-1
```
**מה קרה כאן?** `date[:first]` הוא מההתחלה עד המקום first, **לא כולל** אותו. כש‑`find` לא מוצאת, היא מחזירה **-1** (ולא שגיאה).