דלג לתוכן
נושאים
  • 1 התחלה
    1.1

    התוכנית הראשונה שלך

    Python מנפשת את הקוד שלך שורה אחר שורה. כל שורה היא הוראה. תוכנית היא פשוט רשימה של הוראות שנפשות מהלמעלה למטה.

    הפונקציה print() מציגה טקסט על המסך. דבר זה נקרא תפוקה. טקסט בתוך סימני ציטוט הוא מחרוזת (string).

    print("Hello, world!")
    print("I am learning Python")
    
    • כל print() מתחיל שורה חדשה.
    • סימני ציטוט יכולים להיות "double" או 'single' — שניהם יוצרים מחרוזת.
    • תוכנית לא עושה כלום עד שתפעיל אותה.
    קוד מקור עובר דרך המתרגם כדי לייצר תפוקה
    קוד מקור עובר דרך המתרגם כדי לייצר תפוקה
    1.2

    הערות וסגנון כתיבה

    הערה מתחילה עם #. Python מתעלם מכל מה שמגיע אחרי ה# בשורה זו. הערות מסבירות את הקוד שלך לאנשים; הן אינן משנות את מה שהקוד עושה.

    # This line is a note for humans
    print("Hi")        # you can also comment at the end of a line
    

    סגנון טוב הופך את הקוד לקריא:

    • השתמש בשמות ברורים המבטאים מה המשמעות של ערך.
    • הנח הוראה אחת בכל שורה.
    • אל תוסיף רווחים בהתחלת שורה רגילה. ב-Python, רווחים בהתחלה (רווחי הזזה / indentation) הם בעלי משמעות מיוחדת, ולכן רווח שגוי גורם לשגיאה.
    1.3

    קלט, עיבוד, תפוקה

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

    הפונקציה input() קוראת טקסט שהמשתמש מקליד. היא תמיד מחזירה מחרוזת.

    name = input("What is your name? ")
    print("Hello, " + name)
    
    • input() מחכה למשתמש להקליד וללחוץ Enter.
    • שמור את הטקסט שהוזן במשתנה כדי שתוכל להשתמש בו מאוחר.
    • מכיוון ש-input() מחזיר מחרוזת, שינה אותו עם int(...) תחילה אם אתה זקוק למספר.

    שגיאות נפוצות

    • שכחת הפסקאות: print(Hello) מחפש משתנה בשם Hello ומפעיל NameError. טקסט צריך פסקאות: print("Hello").
    • רווח יתר ב-תחלת שורה: Python קורא מקדמות כמבנה, ולכן מפעיל IndentationError.
    • הנחה ש-input() מחזיר מספר. הוא תמיד מחזיר מחרוזת, לכן עטוף אותו ב-int(...) לפני ביצוע פעולות מתמטיות.
  • 2 משתנים, סוגים ומפעילים
    2.1

    משתנים והקצה

    משתנה הוא שם לערך. יוצרים אותו באמצעות =, המכונה הקצה. השם נמצא בצד שמאל; הערך נמצא בצד ימין.

    age = 17
    name = "Mei"
    price = 9.99
    print(age, name, price)
    

    עכשיו age מכיל את 17. השתמש בשם בכל מקום שבו אתה זקוק לערך, ושנה אותו מאוחר יותר:

    age = 17
    age = age + 1   # age is now 18
    print(age)
    
    משתנה הוא שם הקשור לערך אחסון
    כל שם משתנה מצביע על ערך בזיכרון
    • הסימן = לא פירושו "שווה". פירושו "שמור את הצד הימני תחת השם השמאלי".
    • לבדוק אם שני ערכים שווים, השתמש ב-== (ראה למטה).
    2.2

    מספרים: int ו-float

    ל-Python יש שני סוגי מספרים עיקריים. שלם (int) הוא מספר שלם כמו 17. עשרוני (float) יש לו נקודה עשרונית כמו 9.99.

    פעולות אלו עובדות על מספרים:

    פעולה משמעות דוגמה תוצאה
    + חיבור 3 + 2 5
    - חיסור 3 - 2 1
    * כפל 3 * 2 6
    / חלוקה (תמיד עשרוני) 7 / 2 3.5
    // חלוקה שלמה 7 // 2 3
    % שארית (מודולו) 7 % 2 1
    ** מעלה 2 ** 3 8
    • / תמיד מחזיר מספר עשרוני, לכן 4 / 2 הוא 2.0.
    • // ו-% באים יחד: 17 // 5 הוא 3, ו-17 % 5 הוא 2.
    2.3

    ביטויים והמרת סוגים

    ביטוי הוא כל דבר שמחזיר ערך, כמו 3 + 4 * 2. Python משתמשת בסדר מתמטי רגיל (* ו-/ לפני + ו--); הוסף סוגריים כדי להבהיר את הסדר.

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

    age = int("17")        # text "17" -> number 17
    price = float("9.99")  # text -> 9.99
    label = str(17)        # number -> text "17"
    print(age, price, label)
    
    • int("abc") יכשל, לכן המר רק טקסט שנראה כמו מספר.
    • מערבוב סוגים גם כן גורם לכישלון: "age: " + 17 היא שגיאה; כתוב "age: " + str(17).
    2.4

    בוליאנים והשוואות

    בוליאן הוא אחד משני הערכים האפשריים: True או False. השוואה מחזירה בוליאן.

    מפעיל משמעות
    == שווה ל-
    != לא שווה ל-
    < > קטן / גדול מ-
    <= >= קטן / גדול מ- או שווה ל-
    print(7 > 2)        # True
    print(3 == 3.0)     # True
    age = 20
    print(age >= 18)    # True
    

    חבר השוואות עם and, or, not:

    age = 20
    print(age >= 13 and age <= 19)   # True only for a teenager
    

    שגיאות נפוצות

    • / תמיד מחזיר מספר עשרוני, גם אם 4 / 2 הוא 2.0. השתמש ב-// כאשר אתה רוצה מספר שלם.
    • שימוש ב-= במקום שהכוונה היא ל-==: = מקנה ערך, בעוד ש-== בודק האם שני ערכים שווים זה לזה.
    • חיבור מחרוזת ומספר: "age: " + 5 גורמת ל-TypeError. המר תחילה עם str(5).
    • מספרים עם חוליה אינם מדויקים, לכן 0.1 + 0.2 אינו בדיוק שווה ל0.3 — יש להימנע מ== על תוצאות מספרים עם חוליה.
  • 3 מחרוזות
    3.1

    אינדקסינג

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

    קראו תווית אחת באמצעות סוגריים מרובעים:

    word = "Python"
    print(word[0])    # P  (the first character)
    print(word[2])    # t
    print(len(word))  # 6  (how many characters)
    
    • הספירה מתחילה ב-0, ולכן האינדקס האחרון הוא len(word) - 1.
    • אינדקס שלילי סופר מהסוף: word[-1] הוא התווית האחרונה.
    word = "Python"
    print(word[-1])   # n
    print(word[-2])   # o
    
    • אינדקס הגדול מדי גורם לשגיאה (שגיאת IndexError).
    s[start:stop] הוא חלון פתוח למחצה של תוויות
    s[start:stop] הוא חלון פתוח למחצה של תוויות
    3.2

    חיתוך (Slicing)

    חיתוך לוקח חלק ממחרוזת. כתבו word[start:end]. החיתוך שומר על start אך עצור לפני end.

    word = "Python"
    print(word[0:3])   # Pyt   (positions 0, 1, 2)
    print(word[2:5])   # tho
    
    • השאירו את start ריק כדי להתחיל ב-0; השאירו את end ריק כדי להגיע לסוף.
    word = "Python"
    print(word[:3])    # Pyt
    print(word[3:])    # hon
    
    • מספר שלישי הוא הצעד. word[::-1] הופך את המחרוזת הפוכה.
    print("Python"[::-1])   # nohtyP
    
    3.3

    שיטות מחרוזות ואורך

    שיטה היא פונקציה השייכת לערך. קוראים אותה עם נקודה:

    name = "mei chen"
    print(name.upper())     # MEI CHEN
    print(name.title())     # Mei Chen
    print(len(name))        # 8
    

    מחרוזות בלתי ניתנות לשינוי: שיטה מחזירה מחרוזת חדשה ולא משנה מעולם את המקורית.

    name = "mei"
    print(name.upper())     # MEI  (the returned value)
    print(name)             # mei  (the original is unchanged)
    

    שיטות נפוצות (כל אחת מחזירה ערך חדש):

    שיטה משמעות דוגמה תוצאה
    .upper() / .lower() שינוי קטליות "Hi".lower() hi
    .strip() הסרת רווחים בקצוות " hi ".strip() hi
    .replace(a, b) החלף טקסט "cat".replace("c", "b") bat
    .split(sep) פצל לרשימה "a,b".split(",") ['a', 'b']

    חבר מחרוזות באמצעות +. פעולה זו נקראת הדבקה:

    first = "Mei"
    last = "Chen"
    print(first + " " + last)   # Mei Chen
    
    3.4

    f-strings (מחרוזות מקודדות)

    מחרוזת f בונה טקסט מתוך ערכים. הוסף f לפני התגית, ולאחר מכן כתוב {...} סביב הערך.

    name = "Mei"
    age = 17
    print(f"{name} is {age} years old")   # Mei is 17 years old
    
    • כל ביטוי יכול להיכנס לתוך הסוגריים.
    • {value:.2f} מעגל לש 2 ספרות אחרי הנקודה.
    price = 9.5
    print(f"Two cost {price * 2}")        # Two cost 19.0
    print(f"Pi is about {3.14159:.2f}")   # Pi is about 3.14
    

    שגיאות נפוצות

    • מחרוזות אינן ניתנות לשינוי במקום: s[0] = "x" יגרום לשגיאה. במקום זאת, בנה מחרוזת חדשה.
    • האינדוקס מתחיל ב-0; האות האחרונה היא s[-1], ו-s[len(s)] הוא מחוץ לתחום.
    • חתיכה s[a:b] כוללת את a אך עצירה לפני b.
    • שיטות מחרוזות מחזירות מחרוזת חדשה: s.upper() לא יעשה שום דבר אלא אם תאחסן את התוצאה.
  • 4 בחירה
    4.1

    if / elif / else

    תוכנית בוחרת מה לעשות עם if. היא מפעילה בלוק ממוקד רק כאשר תנאי הוא אמיתי. השורה if מסתיימת בקולון.

    score = 72
    if score >= 60:
        print("pass")
    # pass
    

    הוסף elif (else-if) למקרים נוספים והוסף else ל"כל שאר המקרים". Python מפעילה את הענף האמיתי הראשון בלבד, ואז מדלגת על שאר הענפים.

    score = 72
    if score >= 80:
        print("A")
    elif score >= 60:
        print("B")
    else:
        print("fail")
    # B
    
    • השוו ערכים באמצעות == (שווה ל-), != (שונה מ-), <, >, <=, >=.
    • השוואה נותנת בוליאני — או True או False.
    if / elif / else: רק ענף אחד יוצא לפועל
    if / elif / else: רק ענף אחד מופעל
    4.2

    שילוב תנאים

    חבר תנאים באמצעות and, or, not. and דורש ששתי הצדדים יהיו אמינים; or דורש שאחד מהצדדים יהיה אמיתי; not הופך בוליאני.

    age = 16
    has_ticket = True
    if age >= 18 and has_ticket:
        print("entry allowed")
    else:
        print("entry refused")
    # entry refused
    
    • השתמש בסוגריים כדי להבהיר את הסדר: (a or b) and c.
    temp = 30
    if temp > 25 and not temp > 35:
        print("warm but ok")
    # warm but ok
    

    שגיאות נפוצות

    • כתוב elif, לא else if.
    • כל קו if / elif / else מסתיים בנקודה-פסיק :, וגוף הקוד חייב להיות מוזז ימינה (ממוקם בתוך תוכנית).
    • if x = 5: הוא שגיאה — השתמש ב== לערך השוואה.
    • else אינו מקבל תנאי; רק if ו-elif עושים זאת.
  • 5 איטרציה ⟦number⟧
    5.1

    לולאות for ו-range

    לולאה חוזרת על קוד. לולאת for חוזרת פעם אחת עבור כל פריט ברצף. range(n) נותן את המספרים 0 ועד n - 1.

    for i in range(5):
        print(i)
    # 0, then 1, 2, 3, 4 (each on its own line)
    
    • range(a, b) הולך מ-a ועד (אך אינו כולל) b.
    • range(a, b, step) מוסיף צעד בכל פעם.
    for n in range(2, 11, 2):
        print(n)        # 2 4 6 8 10
    
    for i in range(n): הגוף רץ עם i = 0 … n-1
    for i in range(n): הגוף רץ עם i = 0 … n-1
    5.2

    דוגמת המכונה (Accumulator pattern)

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

    total = 0
    for n in range(1, 6):
        total = total + n
    print(total)        # 15
    
    • אותה רעיון סופר כמה פריטים עומדים במבחן מסוים.
    count = 0
    for letter in "banana":
        if letter == "a":
            count = count + 1
    print(count)        # 3
    
    5.3

    לולאות while

    לולאת while חוזרת כל עוד תנאי נשאר אמת. שינה משהו בפנים, או שהיא לעולם לא תיעצר – לולאה אינסופית.

    n = 1
    while n <= 3:
        print(n)
        n = n + 1
    # 1 2 3
    
    • break יוצא מהלולאה מיידית.
    total = 0
    while True:
        total = total + 10
        if total >= 30:
            break
    print(total)        # 30
    
    5.4

    לולאות מצטבות

    לולאה בתוך לולאה אחרת היא לולאה מקוננת. הלולאה הפנימית רצה במלואה עבור כל סיבוב של הלולאה החיצונית.

    for row in range(3):
        line = ""
        for col in range(3):
            line = line + "*"
        print(line)
    # ***
    # ***
    # ***
    

    שגיאות נפוצות

    • range(n) הולך מ-0 עד n - 1, לא מ-1 עד n – הטעות הקלאסית באחד (off-by-one error).
    • שינוי רשימה בזמן שחורצים עליה מדלג על פריטים; חרוץ על העתק אם אתה חייב להסיר דברים.
    • לשכוח לשנות את משתנה הלולאה ב-while גורם לה להסתובב לנצח.
    • הזזה (indentation) קובעת מה נמצא בתוך הלולאה; קו עם הזזה שגויה ירצה פעם אחת בלבד, לאחר הלולאה.
  • 6 רשימות ורשימות דו-ממדיות 2
    6.1

    רשימות

    רשימה מחזיקה ערכים רבים בסדר, בתוך []. לכל פריט יש אינדקס (מ-0).

    scores = [88, 71, 95]
    print(scores[0])      # 88
    print(len(scores))    # 3
    scores.append(60)     # add to the end
    print(scores)         # [88, 71, 95, 60]
    
    • שינוי פריט לפי האינדקס שלו: scores[1] = 100.
    • רשימה יכולה לגדול ולהתכווץ; מחרוזת טקסט לא יכולה.

    כלי הרשימה לשימוש יומיומי:

    כלי ביצוע פעולה
    a.append(x) מוסיף x בסוף
    a.insert(i, x) מכניס את x בעמדה i
    a.remove(x) מסיר את ה-x הראשון
    a.pop() / a.pop(i) מסיר ומחזיר את הפריט האחרון / פריט i
    a.sort() ממיינת את הרשימה באתרה
    sorted(a) מחזירה רשימה חדשה וממויינת
    x in a האם x נמצא ברשימה?
    len(a), sum(a), max(a), min(a) גודל וחשבונות מהירים
    אינדקסים של רשימה מתחילים ב-0
    אינדקסים של רשימה מתחילים ב-0
    6.2

    עיבור רשימה

    מעבר על רשימה הוא מבקר בכל פריט. לולאת for עושה זאת ללא צורך באינדקס.

    scores = [88, 71, 95]
    total = 0
    for s in scores:
        total = total + s
    print(total)          # 254
    
    • השתמש ב-enumerate כאשר גם אתה זקוק לאינדקס.
    for i, name in enumerate(["a", "b"]):
        print(i, name)    # 0 a  /  1 b
    
    6.3

    רשימות דו-ממדיות (2-D) (טבלאות)

    רשימה מסוג 2-D היא רשימת רשימות — טבלה של שורות ועמודות. השתמש במדדים: grid[row][col].

    grid = [[1, 2, 3],
            [4, 5, 6]]
    print(grid[0][2])     # 3
    print(grid[1][0])     # 4
    
    • לולאה פנימית מבקרת בכל תא.
    grid = [[1, 2], [3, 4]]
    for row in grid:
        for value in row:
            print(value, end=" ")
    print()               # 1 2 3 4
    
    6.4

    רשימות הבעות

    רשימת הבעות בונה רשימה חדשה בשורה אחת: [expression for item in sequence].

    squares = [x * x for x in range(5)]
    print(squares)        # [0, 1, 4, 9, 16]
    
    • הוסף if כדי לשמור רק חלק מהפריטים.
    evens = [n for n in range(10) if n % 2 == 0]
    print(evens)          # [0, 2, 4, 6, 8]
    
    6.5

    טופלים ומאגרים

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

    point = (3, 4)
    x, y = point            # unpacking
    print(x, y)             # 3 4
    

    פונקציה הזקוקה להחזיר שני תוצאות מחזירה טופל:

    def min_max(nums):
        return min(nums), max(nums)
    
    lo, hi = min_max([5, 2, 9])
    print(lo, hi)           # 2 9
    

    מאגר (Set) מאחסן כל ערך פעם אחת, ללא סדר. הוא מושלם להסרת כפילויות ולבדיקות חברות מהירות.

    votes = ["red", "blue", "red", "green", "red"]
    colours = set(votes)
    print(len(colours))         # 3  (duplicates removed)
    print("blue" in colours)    # True
    

    שגיאות נפוצות

    • b = a משתף ברשימה אחת. a.copy() או a[:] יוצרים רשימה חיצונית חדשה, אך פריטים פנימיים מתחלפים נשארים משותפים (העתקה רדודה).
    • הפריט האחרון הוא a[-1]; a[len(a)] מחוץ לתחום.
    • append מוסיף פריט אחד; השתמש בextend או ב+ כדי לחבר רשימה נוספת.
    • בניית גריד עם [[0]*3]*3 יוצרת שלוש העתקים של אותה שורה. בנה את השורות בלולאה במקום זאת.
    • טופל (tuple) עם פריט אחד דורש פסיק: (5,), ולא (5).
    • למאגר אין סדר ואין כפילויות, ולכן לא ניתן לגשת אליו באמצעות s[0].
  • 7 מילונים (Dictionaries)
    7.1

    מילונים

    מילון (dict) מאחסן זוגות מפתח → ערך. אתה מחפש ערך לפי המפתח שלו, ולא לפי מדד מספרי.

    student = {"name": "Mei", "score": 88}
    print(student["name"])     # Mei
    print(student["score"])    # 88
    

    הוספה ועדכון

    הערכה למפתח תוסיף אותו, או תעדכן קיים.

    student = {"name": "Mei"}
    student["score"] = 88      # add a new key
    student["score"] = 90      # update the value
    print(student)             # {'name': 'Mei', 'score': 90}
    

    בדיקה ולולאה

    השתמש בin לבדיקת נוכחות מפתח. לולאה על המפתחות, או על .items() כדי לקבל גם מפתח וגם ערך.

    student = {"name": "Mei", "score": 90}
    print("score" in student)  # True
    for key, value in student.items():
        print(key, "=", value)
    # name = Mei
    # score = 90
    
    • .get(key, default) מחזיר ערך ברירת מחדל כאשר המקרא חסר — ללא שגיאה.
    student = {"name": "Mei"}
    print(student.get("age", 0))   # 0
    

    הדפוס הקלאסי במבחן — ספור כמה פעמים כל ערך מופיע:

    word = "banana"
    counts = {}
    for letter in word:
        counts[letter] = counts.get(letter, 0) + 1
    print(counts)   # {'b': 1, 'a': 3, 'n': 2}
    
    • .get(letter, 0) מספק 0 בפעם הראשונה שמקרא נראה, ולכן אין KeyError.

    שגיאות נפוצות

    • קריאת מפתח חסר באמצעות d[key] גורמת לשגיאת KeyError; השתמש ב-d.get(key) או בדוק תחילה את if key in d.
    • הצבת d[key] שוב מחקית את הערך הישן — המקראים הם ייחודיים.
    • המקראים חייבים להיות בלתי משנים, כמו מחרוג או מספר — רשימה לא יכולה לשמש כמקרא.
    מילון מתאם כל מקרא לערך אחד
    מילון מתאם כל מקרא לערך אחד
  • 8 פונקציות ו abstraction (הפשטה)
    8.1

    הגדרת וקריאת פונקציות

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

    def greet():
        print("Hello!")
    
    greet()        # Hello!
    greet()        # Hello!
    
    • הקוד בתוך הפונקציה מוצא לפועל רק כאשר אתה קורא לה.
    def מגדיר; call מפעיל; return שולח ערך בחזרה
    def מגדיר; call מפעיל; return שולח ערך בחזרה
    8.2

    ערכים מוחזרים

    פונקציה יכולה להחזיר ערך עם return. הקריאה אז מייצגת את הערך הזה.

    def square(n):
        return n * n
    
    print(square(5))          # 25
    print(square(3) + 1)      # 10
    
    • return מסתיימת בפונקציה מיידית. פונקציה ללא return מחזירה None.
    8.3

    פרמטרים, ארגומנטים ותחום תוקף

    פרמטר הוא השם בתוך ה-def. ארגומנט הוא הערך שעובר.

    def power(base, exp):         # base, exp are parameters
        return base ** exp
    
    print(power(2, 3))            # 8  (2 and 3 are arguments)
    

    משתנה שנוצר בתוך פונקציה הוא מקומי — הוא קיים רק שם. האזור הזה הוא התחום שלו.

    def f():
        x = 10            # local to f
        return x
    
    print(f())            # 10
    # print(x) here would be an error: x is not defined outside f
    

    לפרמטר יכול להיות ערך ברירת מחדל, המשמש כאשר הקורא משאיר אותו מחוץ:

    def greet(name, greeting="Hello"):
        return greeting + ", " + name
    
    print(greet("Mei"))              # Hello, Mei
    print(greet("Sam", "Welcome"))   # Welcome, Sam
    
    8.4

    חילוק תהליכים

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

    def area_of_rectangle(w, h):
        return w * h
    
    print(area_of_rectangle(4, 5))   # 20
    
    • פונקציה טובה עושה משימה אחת, יש לה שם ברור, והיא נמנעת מהעתיקת קוד.
    8.5

    מודולים וייבואים

    מודול הוא קובץ של פונקציות מוכנות. תביא אחד לתוך התוכנית באמצעות import.

    import random
    random.seed(0)               # makes the result repeatable
    print(random.randint(1, 6))  # a dice roll
    
    import math
    print(math.sqrt(16))         # 4.0
    

    שגיאות נפוצות

    • פונקציה מחזירה None אלא אם כן כתבת return. הדפסה אינה זהה להחזרה.
    • לעולם אל תשתמש בברירת מחדל מתוחברת כמו def f(x=[]) — אותה רשימה משותפת בין כל הקריאות.
    • משתנה שמוגדרת בתוך פונקציה היא מקומית ואינה נראית מחוץ לה.
    • הרץ פונקציה עם f(); כתיבת f לבדו רק מייחסת לה שם.
  • 9 שגיאות, חריגות ובדיקות
    9.1

    שגיאות וניקוי שגיאות

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

    שגיאות Python נפוצות: סינטקס, שם, סוג, אינדקס
    שגיאות Python נפוצות: סינטקס, שם, סוג, אינדקס
    # A runtime error, caught so this block still finishes:
    try:
        print(10 / 0)
    except ZeroDivisionError:
        print("cannot divide by zero")
    # cannot divide by zero
    
    • פייתון מדפיס תרגיל עקבות המראה היכן שהכשל התרחש. קרא אותו מלמטה למעלה.
    9.2

    ניסיון / טיפול בחריגות / השקת שגיאה

    שים קוד סיכון בtry; אם הוא כושל, except לוכד את השגיאה במקום להתמוטט.

    def to_int(text):
        try:
            return int(text)
        except ValueError:
            return 0
    print(to_int("abc"))   # 0
    
    • לכד סוג ספציפי (ValueError, ZeroDivisionError, …).
    • raise יוצר שגיאה משלך במטרה.
    def set_age(age):
        if age < 0:
            raise ValueError("age cannot be negative")
        return age
    
    try:
        set_age(-1)
    except ValueError as err:
        print("error:", err)
    # error: age cannot be negative
    
    9.3

    בדיקות ויציבות

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

    def average(nums):
        if len(nums) == 0:        # edge case: empty list
            return 0
        return sum(nums) / len(nums)
    
    print(average([2, 4, 6]))     # 4.0
    print(average([]))            # 0
    
    • קוד איתן מטפל בקלט מוזר בצורה הולמת במקום להתמוטט.

    שגיאות נפוצות

    • אל תשתמש ב-except: ריק — תלכד את השגיאה הספציפית, למשל except ValueError:.
    • שגיאת סינטקס עצרת את כל התוכנית לפני ההפעלה, לכן תתקן אותן תחילה.
    • בדוק את מקרי הקצה (כניסה ריקה, אפס, הערך הגדול ביותר), ולא רק את המקרה הפשוט.
  • 10 קבצים
    10.1

    קריאה וכתיבה בקבצי טקסט

    קובץ טקסט מאחסן טקסט בכונן. פתח אותו עם open(name, mode) כאשר המצב מציין קריאה או כתיבה. תמיד השתמש ב-with, שיסגור עבורך את הקובץ.

    כתיבה

    מצב "w" כותב קובץ חדש ומחקר כל קובץ ישן.

    with open("notes.txt", "w") as f:
        f.write("first line\n")
        f.write("second line\n")
    print("saved")            # saved
    

    קריאה

    מצב "r" (ברירת מחדל) קורא. .read() מחזיר את כל הקובץ כמחרוזת אחת.

    with open("notes.txt", "w") as f:
        f.write("hello\nworld\n")
    with open("notes.txt") as f:
        print(f.read().strip())   # hello / world
    

    שורה בשורה

    לולוא על הקובץ כדי לקבל שורה אחת בכל פעם. .strip() מסיר את תווה החדש שורה בסוף.

    with open("data.txt", "w") as f:
        f.write("Mei,88\nSam,71\n")
    with open("data.txt") as f:
        for line in f:
            name, score = line.strip().split(",")
            print(name, "scored", score)
    # Mei scored 88
    # Sam scored 71
    

    הוספה

    מצב "a" מוסיף בהמשך — הוא מוסיף בסוף מבלי למחוק.

    with open("log.txt", "w") as f:
        f.write("line 1\n")
    with open("log.txt", "a") as f:
        f.write("line 2\n")
    with open("log.txt") as f:
        print(f.read().strip())   # line 1 / line 2
    
    מצב משמעות
    "r" קריאה (ברירת מחדל)
    "w" כתיבה (מחקר תחילה)
    "a" הוספה (הוספה לסוף)

    שגיאות נפוצות

    • תמיד סגור קובץ, או השתמש ב-with open(...) as f: שיסגור עבורך.
    • read() נותן את כל הקובץ כמחרוזת אחת, וכל שורה עדיין מסתיימת ב-\n.
    • פתיחה עם "w" מוחקת את הקובץ תחילה; השתמש ב-"a" להוספה בסוף.
    פתיחה → קריאה/כתיבה → סגירה (עם סגירה אוטומטית)
    פתיחה → קריאה/כתיבה → סגירה (עם סגירה אוטומטית)
  • 11 עיצוב אלגוריתם
    11.1

    אלגוריתמים ופירוק

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

    # Algorithm: find the largest number in a list
    def largest(nums):
        best = nums[0]
        for n in nums:
            if n > best:
                best = n
        return best
    
    print(largest([3, 9, 2, 7]))   # 9
    
    • חוץ מהפרטים אומר להתעלם מפירוט: משתמשים ב-largest(...) מבלי לקרוא מחדש כיצד זה עובד.
    11.2

    סימולציות ותרשימי זרימה

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

    SET best TO first number
    FOR Each number n
        IF n > best
          THEN
            SET best TO n
    OUTPUT best
    

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

    11.3

    רקורסיה וערימת ההתקשרות

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

    מערך קריאות עבור factorial(3): כל קריאה מחכה, ולאחר מכן מחזירה ערך בסדר הפוך
    מערך קריאות עבור factorial(3): כל קריאה מחכה, ולאחר מכן מחזירה ערך בסדר הפוך
    def fact(n):
        return 1 if n <= 1 else n * fact(n - 1)
    
    print(fact(5))     # 120
    
    • כל התקשרות השהוייה יושבת בערימת ההתקשרות עד שההתקשרות מעליה מחזירה ערך.

    שגיאות נפוצות

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

    סוגי נתונים מ抽象ים (ADTs)

    סוג נתונים抽象 (ADT) מתאר נתונים מסוימים ואת הפעולות עליהם, בנפרד מהאופן שבו הם בונים. משתמשים בו דרך הפעולות שלו, לא דרך האחסון הפנימי.

    # A stack ADT, built on a list
    s = []
    s.append(1)        # add
    s.append(2)
    print(s.pop())     # 2  (remove the most recent)
    
    12.2

    ערוכים

    ערך הוא אחרון-נכנס, ראשון-יוצא (LIFO). מדחפים על העליון ומוצאים מהעליון.

    ערך מוצא מהעליון (LIFO); תור מוצא מהחלון (FIFO)
    ערך מוצא מהעליון (LIFO); תור מוצא מהחלון (FIFO)
    stack = []
    stack.append("a")
    stack.append("b")
    print(stack.pop())   # b
    print(stack.pop())   # a
    
    12.3

    תוריות

    תורית היא סדרה בהם-ראשון, יוצא-ראשון (FIFO). מוסיפים לתורית מהגב ומסירים ממנה מהחזית.

    queue = []
    queue.append("a")     # enqueue
    queue.append("b")
    print(queue.pop(0))   # a  (dequeue the front)
    print(queue.pop(0))   # b
    
    12.4

    רשימות מקשרות

    רשימה מקשרת היא שרשרת של צמתים. כל צומח מכיל נתונים ומצביע לצומח הבא; האחרון מצביע על None.

    רשימה מקשרת: כל נודה מכילה נתונים וקישור לנודה הבאה, והסיום הוא ב-None
    רשימה מקשרת: כל נודה מכילה נתונים וקישור לנודה הבאה, והסיום הוא ב-None
    n3 = {"data": 3, "next": None}
    n2 = {"data": 2, "next": n3}
    n1 = {"data": 1, "next": n2}
    node = n1
    while node is not None:      # traverse to the end
        print(node["data"])
        node = node["next"]
    # 1 2 3
    
    12.5

    טבלאות פריטור

    טבלת TODO maps מפתח למיקום באמצעות פונקציית TODO hash. שני מפתחות יכולים ליפול אותו מקום — התנגשות. ה-dict של Python היא טבלת TODO hash, ולכן חיפוש מהיר.

    פונקציית פריטור מתאמת כל מקדף למיקום; שני מקדפים שונים עשויים להתנגש במיקום אחד
    פונקציית פריטור מתאמת כל מקדף למיקום; שני מקדפים שונים עשויים להתנגש במיקום אחד
    table = {}
    table["Mei"] = 88
    table["Sam"] = 71
    print(table["Mei"])   # 88  (fast lookup by key)
    
    12.6

    עצי TODO בינאריים

    עץ חיפוש בינארי (BST) שומר על סדר: כל צאצא שמאלי קטן מהנודה שלו, וכל צאצא ימני גדול ממנה. החיפוש נשאר מהיר.

    עץ חיפוש בינארי: ערכים קטנים הולכים שמאלה, ערכים גדולים הולכים ימינה
    עץ חיפוש בינארי: ערכים קטנים הולכים שמאלה, ערכים גדולים הולכים ימינה
    def insert(root, val):
        if root is None:
            return {"val": val, "left": None, "right": None}
        if val < root["val"]:
            root["left"] = insert(root["left"], val)
        else:
            root["right"] = insert(root["right"], val)
        return root
    
    def inorder(root):
        if root is None:
            return []
        return inorder(root["left"]) + [root["val"]] + inorder(root["right"])
    
    tree = None
    for v in [5, 3, 8, 1, 4]:
        tree = insert(tree, v)
    print(inorder(tree))   # [1, 3, 4, 5, 8]
    
    12.7

    גרפים

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

    גרף של קודקודים וקשתות, עם הצגת רשימת השכנות שלו
    גרף של קודקודים וקשתות, עם הצגת רשימת השכנות שלו
    graph = {"A": ["B", "D"], "B": ["A", "C"], "C": ["B", "D"], "D": ["A", "C"]}
    for vertex in graph:
        print(vertex, "->", graph[vertex])
    # A -> ['B', 'D']  (and so on for B, C, D)
    

    שגיאות נפוצות

    • ערימה היא אחרון-נכנס, ראשון-יוצא; תורית היא ראשון-נכנס, יוצא-ראשון. אל תבלבלו ביניהן.
    • בדקו האם המבנה ריק לפני שתוציאו ממנו פריט בעזרת pop או dequeue.
    • ברשימה מקשרת, איבוד הקישור ל-head מאבד את כל הרשימה.
  • 13 חיפוש, מיון ויעילות
    13.1

    חיפוש ליניארי וחיפוש בנארי

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

    def linear_search(items, target):
        for i in range(len(items)):
            if items[i] == target:
                return i
        return -1     # not found
    
    print(linear_search([4, 8, 2, 9], 2))   # 2
    

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

    def binary_search(items, target):
        lo, hi = 0, len(items) - 1
        while lo <= hi:
            mid = (lo + hi) // 2
            if items[mid] == target:
                return mid
            elif items[mid] < target:
                lo = mid + 1
            else:
                hi = mid - 1
        return -1
    
    print(binary_search([1, 3, 5, 7, 9], 7))   # 3
    
    חיפוש בינארי חוצה את הטווח למחצית בכל צעד — O(log n) ברשימה מסודרת
    חיפוש בינארי חוצה את הטווח למחצית בכל צעד — O(log n) ברשימה מסודרת
    13.2

    מיון (בוער והכנסה)

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

    def bubble_sort(a):
        a = a[:]                          # work on a copy
        for i in range(len(a)):
            for j in range(len(a) - 1 - i):
                if a[j] > a[j + 1]:
                    a[j], a[j + 1] = a[j + 1], a[j]
        return a
    
    print(bubble_sort([5, 2, 4, 1]))      # [1, 2, 4, 5]
    

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

    def insertion_sort(a):
        a = a[:]                           # work on a copy
        for i in range(1, len(a)):
            key = a[i]
            j = i - 1
            while j >= 0 and a[j] > key:   # shift bigger values right
                a[j + 1] = a[j]
                j -= 1
            a[j + 1] = key                 # drop key into the gap
        return a
    
    print(insertion_sort([5, 2, 4, 1]))   # [1, 2, 4, 5]
    
    • בקוד אמיתי, השתמש במובנית sorted() של Python:
    print(sorted([5, 2, 4, 1]))           # [1, 2, 4, 5]
    
    13.3

    יעילות אלגוריתמית

    יעילות שואפת כיצד העבודה גדלה ככל שהקלט גדל. אנו מתארים זאת באמצעות Big-O.

    איך מספר הצעדים גדל בהתאם לגודל הקלט עבור מורכבויות נפוצות
    איך מספר הצעדים גדל בהתאם לגודל הקלט עבור מורכבויות נפוצות
    Big-O שם דוגמה
    $O(1)$ קבוע חיפוש מקלד במילון
    $O(\log n)$ לוגריתמי חיפוש בינארי
    $O(n)$ ליניארי חיפוש ליניארי
    $O(n^2)$ ריבועי מיון בוער
    def steps(n):           # how many steps a linear scan takes
        count = 0
        for i in range(n):
            count = count + 1
        return count
    
    print(steps(100))       # 100  -> O(n)
    
    13.4

    אקראיות וסימולציה

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

    import random
    random.seed(0)
    rolls = [random.randint(1, 6) for _ in range(1000)]
    print(rolls.count(6))   # about 1/6 of 1000
    

    שגיאות נפוצות

    • חיפוש בינארי עובד רק ברשימה מסודרת.
    • Big-O מספר איך הזמן גודל, לא את הזמן המדויק; שיטה O(n²) טובה יותר מ-O(n) רק לקלט קטן מאוד.
    • מיון בוער הוא O(n²) — מתאים ללמידה, אך איטי ברשימות גדולות.
  • 14 תכנות אובייקטי-מונחה (OOP) ופרדיגמות
    14.1

    מחלקות ואובייקטים

    מחלקה היא תבנית. אובייקט הוא דבר אחד שנבנה ממנה (דוגמה). __init__ הוא הקונסטרוקטור שמגדיר כל אובייקט; self הוא האובייקט עצמו.

    class Dog:
        def __init__(self, name):
            self.name = name            # an attribute
        def speak(self):
            return self.name + " says woof"
    
    d = Dog("Rex")
    print(d.speak())     # Rex says woof
    
    • name הוא מאפיין (נתונים באובייקט); speak הוא שיטה (פעולה).

    הוסף __str__ כדי לשלוט במוצג על ידי print(obj):

    class Dog:
        def __init__(self, name):
            self.name = name
        def __str__(self):
            return f"Dog named {self.name}"
    
    print(Dog("Rex"))    # Dog named Rex
    
    מחלקה היא תבנית; קריאה שלה יוצרת אובייקט
    מחלקה היא תבנית; קריאה שלה יוצרת אובייקט
    14.2

    ירושיות, encapsulation ופולימורפיזם

    ירושית מאפשרת למחלקת בת להשתמש במחלקת האב. השתמש בsuper() כדי לקרוא להורה; העלמת שיטה כדי לשנות אותה.

    class Animal:
        def speak(self):
            return "some sound"
    
    class Cat(Animal):
        def speak(self):                # override
            return "meow"
    
    print(Cat().speak())   # meow
    

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

    class Account:
        def __init__(self):
            self._balance = 0           # non-public by convention
        def deposit(self, n):
            self._balance += n
        def balance(self):
            return self._balance
    
    a = Account()
    a.deposit(50)
    print(a.balance())     # 50
    

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

    class Cat:
        def speak(self):
            return "meow"
    
    class Cow:
        def speak(self):
            return "moo"
    
    for animal in [Cat(), Cow()]:
        print(animal.speak())   # meow, then moo
    
    14.3

    פרדיגמות תכנות

    פרדיגמה היא סגנון כתיבת תוכנות. קוד פרוצדורלי הוא רצף של צעדים ופונקציות. קוד ממוקד-אובייקטים מקבץ נתונים ושיטות לתוך אובייקטים. קוד הצהרתי אומר מה אתה רוצה, לא איך (רשימת הבנאה או SQL).

    def total(nums):           # procedural
        t = 0
        for n in nums:
            t += n
        return t
    print(total([1, 2, 3]))    # 6
    
    print(sum([1, 2, 3]))      # 6  (declarative: same result)
    

    שגיאות נפוצות

    • לכל שיטה יש לself כפרמטר הראשון.
    • __init__ מגדיר אובייקט חדש ורץ אוטומטית כאשר אתה יוצר אותו.
    • לשני אובייקטים מאותה מחלקה יש מאפיינים נפרדים; שינוי באחד אינו משנה את השני.
  • 15 ייצוג נתונים
    15.1

    ביטים ובינארי

    ביט הוא 0 או 1 יחיד. מערכת בסיס-2 היא מערכת המספרים: כל מקום שווה פי שניים מהמקום מימינו (1, 2, 4, 8, …). מערכת עשרונית (בסיס-10) היא המספרים הרגילים שלנו.

    ערכי מקום בינאריים: 1101 פירושו 8 + 4 + 1 = 13
    ערכי מקום בינאריים: 1101 פירושו 8 + 4 + 1 = 13
    print(bin(13))         # 0b1101
    print(int("1101", 2))  # 13
    
    • 8 ביטים יוצרים בייט. רוחב קבוע יכול לגרום לעודף (wrap around) כאשר המספר גדול מדי.
    x = 250
    x = (x + 10) % 256     # one byte wraps at 256
    print(x)               # 4
    

    מערכת ספרותית מעוצשית (בסיס 16) היא דרך קומפקטית לקרוא מספרים בינאריים: דיgit מעוצשי אחד עומד בדיוק על ארבעה ביטים. Python כותב מעוצשי באמצעות 0x:

    print(hex(255))        # 0xff
    print(0xFF)            # 255
    print(int("ff", 16))   # 255
    
    15.2

    דחיסה

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

    הצפנת רצף (Run-length encoding) היא שיטה פשוטה ללא אובדן: מאחסנת רצף (חזרה חוזרת) כספירה יחד עם הערך.

    def rle(text):
        out = ""
        i = 0
        while i < len(text):
            run = 1
            while i + run < len(text) and text[i + run] == text[i]:
                run += 1
            out += str(run) + text[i]
            i += run
        return out
    
    print(rle("AAAABBBCCD"))   # 4A3B2C1D
    

    שגיאות נפוצות

    • n ביטים מאחסנים 2**n ערכים שונים, החל מ0 ועד ל2**n - 1.
    • דחיסה מאבדת פרטים ואינה ניתנת לחזור בה; דחיסה ללא אובדן ניתנת להפכה בדיוק.
  • 16 מושגי מחשוב
    16.1

    מהו חישוב והמעגל העיצוב

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

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

    האינטרנט

    האינטרנט הוא רשת של רשתות. נתונים מחולקים לחבילות שעוברות בנפרד ומתחברות מחדש בקצה השני. תקנונים משותפים הנקראים פרוטוקולים (כמו TCP/IP) מאפשרים זאת. אם מסלול אחד נשבר, חבילות נוטלות מסלול אחר — זהו עודפות, שמעניקה סבילות לשגיאות.

    מפת האינטרנט: כל קו הוא מסלול בין שתי רשתות
    מפת האינטרנט: כל קו הוא מסלול בין שתי רשתות
    שכבה משימה
    HTTP בקשה ושליחת דפי אינטרנט
    TCP אספקה אמינה, בסדר
    IP כתובות וניהול מסלולים
    16.3

    חיבוץ מקביל ומפוזר

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

    • לא הכל יכול לרוץ במקביל: חלק מהצעדים חייבים להמתין לתוצאה קודמת.
    16.4

    השפעת החיבוץ

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

    שגיאות נפוצות

    • האינטרנט והאינטרנט העולמי (World Wide Web) אינם אותו דבר: ה-Web הוא שירות אחד הפועל מעל האינטרנט.
    • ליבה נוספת במעבד מועילה רק אם העבודה ניתנת לחלוקה חלקים שניתן לייצר בו זמנית.
  • 17 שילוב הכל יחד
    17.1

    מיזמים קטנים מקצה לקצה

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

    מיזם: ציון ממוצע

    def average(marks):
        if len(marks) == 0:
            return 0
        return round(sum(marks) / len(marks), 1)
    
    print(average([88, 71, 95, 60]))   # 78.5
    

    מיזם: ספירת הצלחות

    def count_passes(marks, pass_mark=60):
        passes = 0
        for m in marks:                 # iteration
            if m >= pass_mark:          # selection
                passes += 1
        return passes
    
    print(count_passes([88, 50, 95, 60]))   # 3
    

    מיזם: סינון לרשימה חדשה

    def merit(marks):
        return [m for m in marks if m >= 80]
    
    print(merit([88, 71, 95, 60]))     # [88, 95]
    

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

    שגיאות נפוצות

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

היכנס או צור חשבון

IGCSE, A-Level & AP