א.6 — לולאות

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

איטרציה (iteration) היא חזרה אחת של הלולאה — ביצוע אחד של גוף הלולאה. אם גוף הלולאה מתבצע עשר פעמים, נאמר שבוצעו עשר איטרציות.

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

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

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

מחברות האוניברסיטה הפתוחה — 3-לולאות

לולאת while

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

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

כדי לכתוב את הלולאה, כותבים while, אחריה את התנאי ובסוף נקודתיים (:). את ההוראות של גוף הלולאה כותבים בשורות הבאות, בהזחה אחידה. אין צורך בסוגריים סביב התנאי.

לפני הלולאה מאתחלים את המשתנים שמופיעים בתנאי — נותנים להם ערכים התחלתיים. כך אפשר לבדוק את התנאי כבר בפעם הראשונה. בדוגמה הבאה המשתנה count מתחיל ב־3, ובכל איטרציה מפחיתים ממנו אחת. התנאי count > 0 קובע אם ממשיכים לספור:

count = 3

while count > 0:
    print(count)
    count -= 1

print("Go!")

פלט

3
2
1
Go!

בדוגמה, בכל איטרציה מדפיסים את count ואז מפחיתים ממנו אחת. לאחר הדפסת 1 ערכו נעשה 0, התנאי count > 0 אינו מתקיים עוד, והלולאה מסתיימת. רק אז מתבצעת ההדפסה Go!, שנמצאת מחוץ לבלוק.

מוודאים שהלולאה תסתיים

לולאה אין־סופית היא לולאה שחוזרת שוב ושוב בלי להגיע לסיום. למשל, אם נשמיט מהדוגמה את count -= 1, הערך יישאר 3 והתנאי ימשיך להתקיים — הלולאה תדפיס 3 ללא הפסקה.

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

יציאה מהלולאה — break

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

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

while True:
    grade = int(input("Grade (negative to finish): "))
    if grade < 0:
        break
    print("Grade received:", grade)

print("Input finished")

אם נקליד 80 ואחריו ‎−1, נקבל את ההרצה הבאה; בשורות הקלט מופיעים גם המספרים שהמשתמש הקליד:

פלט

Grade (negative to finish): 80
Grade received: 80
Grade (negative to finish): -1
Input finished

while True יוצרת לולאה אין־סופית: התנאי שלה תמיד אמת, ולכן היא אינה נעצרת בעקבות בדיקת התנאי. בדוגמה שלנו דואגים לעצור אותה באמצעות break, כשהמשתמש מזין מספר שלילי. ללא היציאה הזאת, הלולאה תמשיך לבקש ציונים שוב ושוב. לכן 80 מודפס כציון, אבל ‎−1 אינו מודפס כציון — יוצאים לפני ההדפסה. בלולאה זו אין משתנה בתנאי; grade מקבל ערך מהקלט לפני שבודקים אותו בתוך הגוף.

צבירת סכום ומניית ציונים

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

ממוצע מחשבים על ידי חיבור כל הערכים וחלוקת הסכום במספר הערכים. למשל, אם המשתמש יקליד 80, 90, 100 ואז ‎−1, נחבר את שלושת הציונים: 80 + 90 + 100 = 270. מכיוון שהוכנסו שלושה ציונים, נחלק את הסכום ב־3 ונקבל ממוצע של 90.

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

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

לאחר סיום הקליטה נחשב את הממוצע באמצעות average = total / count: נחלק את הסכום ששמרנו בצובר בכמות ששמרנו במונה. כך שני המשתנים מספקים בדיוק את הנתונים הדרושים לחישוב.

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

כך משתנים הערכים כשמקלידים 80, 90 ו־100:

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

כעת נשלב את הקליטה, הצבירה והמנייה בלולאה, ואת חישוב הממוצע לאחריה:

total = 0
count = 0

while True:
    grade = int(input("Grade (negative to finish): "))
    if grade < 0:
        break
    total += grade
    count += 1

print("Sum:", total)
print("Number of grades:", count)
if count > 0:
    average = total / count
    print("Average:", average)
else:
    print("No grades entered")

עבור הקלט 80, 90, 100 ואז ‎−1, הדפסות הסיכום לאחר הלולאה הן:

פלט

Sum: 270
Number of grades: 3
Average: 90.0

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

לפני החלוקה בודקים ש־count > 0. אם המשתמש הזין מספר שלילי כבר בקלט הראשון, לא התקבל אף ציון. הסכום והמונה נשארים 0, והקוד מדפיס No grades entered במקום לנסות לחלק באפס.

דילוג על המשך האיטרציה — continue

הפקודה continue מדלגת על שאר ההוראות באיטרציה הנוכחית, אך אינה מסיימת את הלולאה. בלולאת while חוזרים לבדוק את התנאי, ואם הוא מתקיים מתחילה האיטרציה הבאה. בדוגמה נדפיס את המספרים 1 עד 6, מלבד 3:

i = 0

while i < 6:
    i += 1
    if i == 3:
        continue
    print(i)

פלט

1
2
4
5
6

המשתנה i גדל לפני הבדיקה. כשערכו 3, הפקודה continue מדלגת על ההדפסה בלבד. באיטרציה הבאה הוא גדל ל־4 וההדפסות ממשיכות. חשוב שהעדכון יתבצע גם באיטרציה שמדלגים בה על ההדפסה, כדי שהלולאה תוכל להגיע לסיום.

סיום רגיל של לולאה — else

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

attempts = 0

while attempts < 3:
    attempts += 1
    if attempts == 2:
        print("Found")
        break
else:
    print("Not found")

פלט

Found

בניסיון השני מתקיים התנאי attempts == 2, מודפס Found והלולאה נעצרת ב־break. בלוק ה־else לא יבוצע, משום שהלולאה הסתיימה באמצעות break. אילו לא היה נמצא דבר בשלושת הניסיונות, הלולאה הייתה מסתיימת כי attempts < 3 נעשה שקרי, ואז היה מודפס Not found. פירוט על לולאות ו־else.

לולאת for — מעבר על ערכים

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

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

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

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

grades = [80, 90, 100]

for grade in grades:
    print("Grade:", grade)

פלט

Grade: 80
Grade: 90
Grade: 100

בשורה for grade in grades:, השם grade הוא המשתנה שמקבל בכל פעם ציון אחד מהרשימה grades. באיטרציה הראשונה הוא מקבל 80, בשנייה 90 ובשלישית 100. אחרי הציון השלישי אין ערך נוסף, ולכן הלולאה נעצרת. for עצמה מציבה את הערך במשתנה, ולכן אין צורך לאתחל כאן את grade לפני הלולאה.

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

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

text = "Hello world"
has_space = False

for character in text:
    if character == " ":
        has_space = True

print("Contains a space:", has_space)

פלט

Contains a space: True

מתחילים ב־False, כי עדיין לא נמצא רווח. המשתנה character מקבל בתורו את H, אחר כך e, וכן הלאה. כאשר הוא מקבל את תו הרווח, מעדכנים את has_space ל־True. המשתנה נשאר אמת גם בזמן בדיקת שאר התווים. אם לא היה רווח, הוא היה נשאר שקר.

במחרוזת הזאת יש 11 תווים, כולל הרווח, ולכן מתבצעות 11 איטרציות. הלולאה מסתיימת אחרי התו האחרון. אפשר לבדוק קיום רווח בקיצור גם באמצעות " " in text; כאן עברנו תו־תו כדי ללמוד כיצד משתמשים בלולאה.

לולאת for עם range — מספר חזרות ידוע

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

בכתיבה range(4) מתקבלים המספרים 0, 1, 2 ו־3 — ארבעה ערכים, ולכן ארבע איטרציות:

for i in range(4):
    print("i:", i)

פלט

i: 0
i: 1
i: 2
i: 3

הספירה מתחילה ב־0: המשתנה i מקבל את הערכים 0, 1, 2 ו־3, והם מודפסים כפי שהם. מתבצעות ארבע איטרציות, אף שהערך האחרון הוא 3; הערך 4 אינו נכלל בטווח.

אפשר לציין גם התחלה, סיום וצעד: range(start, stop, step). ערך הסיום אינו נכלל:

for i in range(1, 8, 2):
    print(i)

פלט

1
3
5
7

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

תרגיל - ממוצע ציונים של תלמידים בכיתה

כתבו תוכנית לחישוב ממוצע הציונים בכיתה באמצעות לולאת for. הניחו שהציונים המוזנים הם מספרים שלמים בין 0 ל־100.

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

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

פתרון סעיף א — 40 תלמידים

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

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

student_count = 40
total = 0

for i in range(student_count):
    print("Student number:", i + 1)
    grade = int(input("Grade: "))
    total += grade

average = total / student_count
print("Sum:", total)
print("Number of students:", student_count)
print("Average:", average)

למשל, אם ל־20 התלמידים הראשונים נקליד 80 ול־20 הבאים נקליד 100, הדפסות הסיכום לאחר הלולאה יהיו:

פלט

Sum: 3600
Number of students: 40
Average: 90.0

i מקבל את הערכים 0 עד 39, ובכל חזרה נקלט ציון אחד ומתווסף ל־total. אין צורך במונה ציונים נפרד: ידוע שכל אחת מ־40 האיטרציות קולטת בדיוק ציון אחד. אחרי התלמיד האחרון יוצאים מהלולאה ומחשבים את הממוצע. בדוגמה מניחים שמוזנים ציונים שלמים תקינים.

פתרון סעיף ב — מספר תלמידים שנקלט מראש

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

student_count = int(input("Number of students: "))
total = 0

for i in range(student_count):
    print("Student number:", i + 1)
    grade = int(input("Grade: "))
    total += grade

average = total / student_count
print("Sum:", total)
print("Number of students:", student_count)
print("Average:", average)

אם נקליד מספר תלמידים 3, ואחר כך את הציונים 80, 90 ו־100, הדפסות הסיכום יהיו:

פלט

Sum: 270
Number of students: 3
Average: 90.0

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

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

לולאות מקוננות

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

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

נתחיל בדוגמה של לוח הכפל למספרים 1 עד 5. בכל משבצת נציג את מכפלת מספר השורה במספר העמודה. למשל, בשורה 2 ובעמודה 3 יופיע 6. כדי למלא את כל הלוח, נעבור על חמש השורות, ובכל שורה נעבור על חמש העמודות:

for row in range(1, 6):
    for column in range(1, 6):
        print(row * column, end="\t")
    print()

פלט

1	2	3	4	5
2	4	6	8	10
3	6	9	12	15
4	8	12	16	20
5	10	15	20	25

הלולאה החיצונית קובעת את row. כשהוא 1, הלולאה הפנימית מעבירה את column על המספרים 1 עד 5, ולכן מודפסות המכפלות 1, 2, 3, 4 ו־5. אחר כך row עולה ל־2, ו־column מתחיל מחדש ב־1 — כך מתקבלת השורה הבאה, ובה 2, 4, 6, 8 ו־10. התהליך נמשך עד השורה החמישית.

הכתיבה end="\t" מוסיפה טאב אחרי כל מכפלה, במקום לרדת שורה. ה־print() הריק נמצא בתוך הלולאה החיצונית אך מחוץ לפנימית, ולכן יורד שורה רק אחרי הדפסת כל חמש המכפלות. בסך הכול מתבצעים 25 חישובי כפל: 5 שורות כפול 5 עמודות. המכפלה הגדולה בלוח היא 25.

תרגיל — התלמיד בעל הממוצע הגבוה ביותר

בכיתה יש 10 תלמידים ולכל תלמיד 3 ציונים. כתבו תוכנית שקולטת את שמו של כל תלמיד ואת שלושת ציוניו, ומדפיסה את שם התלמיד בעל הממוצע הגבוה ביותר ואת הממוצע שלו. הניחו שהציונים שלמים ובטווח 0–100. אם יש שוויון בממוצע הגבוה ביותר, הציגו את התלמיד הראשון שהגיע אליו.

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

best_average = -1
best_student_name = ""

for student in range(1, 11):
    student_name = input(f"Student {student} name: ")
    total = 0

    for grade_number in range(1, 4):
        print("Grade number:", grade_number)
        grade = int(input("Grade: "))
        total += grade

    average = total / 3
    if average > best_average:
        best_average = average
        best_student_name = student_name

print("Best student:", best_student_name)
print("Highest average:", best_average)

למשל, אם לתלמידה השנייה נקליד את השם Dana ואת הציונים 80, 90 ו־100, ולכל אחד משאר התלמידים נקליד את שמו ואת הציון 70 בכל שלושת המקצועות, הדפסות הסיכום יהיו:

פלט

Best student: Dana
Highest average: 90.0

כך הקוד פועל:

1. הלולאה החיצונית מתחילה בתלמיד 1. קולטים את שמו לתוך student_name פעם אחת, מאפסים את total, ואז הלולאה הפנימית קולטת שלושה ציונים ומוסיפה אותם לסכום.
2. אחרי הלולאה הפנימית מחשבים את הממוצע. אם הוא גדול מהשיא הקודם, שומרים את הממוצע ב־best_average ואת שם התלמיד ב־best_student_name.
3. עוברים לתלמיד הבא, קולטים את שמו, מאפסים מחדש את סכום הציונים שלו ומבצעים שוב את כל שלוש האיטרציות של הלולאה הפנימית.
4. אחרי התלמיד העשירי הלולאה החיצונית מסתיימת, ומדפיסים את שם התלמיד ואת הממוצע שנשמרו.

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

מתחילים את best_average ב־‎−1, ערך קטן מכל ממוצע אפשרי בתרגיל, ולכן התלמיד הראשון מעדכן אותו גם אם כל ציוניו 0. משתמשים ב־> ולא ב־>=, כדי שבמקרה של שוויון יישמר התלמיד הראשון.

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