2.2 לולאות הרצאה

לולאות

• המון פעמים בתכנות אנחנו רוצים להריץ איזשהו קטע קוד מספר פעמים.
• מה אם נרצה להדפיס 10 פעמים "hello"?
  

  print("hello")
  print("hello")
  print("hello")
  print("hello")
  print("hello")
  print("hello")
  print("hello")
  print("hello")
  print("hello")
  print("hello")
  

• אפשר להשתמש בלולאות כדי לכתוב את הקוד הזה בצורה יותר טובה

לולאת while:

• לולאה מסוג while היא מבנה קוד בתכנות שמבצע בלוק של קוד שוב ושוב כל עוד תנאי מסוים מתקיים. הלולאה בודקת את התנאי לפני כל ביצוע של הבלוק, ואם התנאי הוא אמת (True), היא ממשיכה לרוץ. ברגע שהתנאי הופך לשקר (False), הלולאה נפסקת. הנה כמה דוגמאות:
• (מומלץ להריץ את קטעי הקוד הבאים בשביל לראות את התוצאה).

while 10 > 5:
    print("10 is greater than 5.") 

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

count = 0
while count != 10:
    print(count)
    count += 1

- בדוגמה זו הקוד ידפיס את הספרות 0 עד 9.
- בואו נסביר למה בכך שנחלק את מה שהמחשב עושה שלב שלב:
1. ראשית, המחשב מקבל את את הפרמטר count = 0 ובעצם "שומר אותו" בזיכרון שלו.
2. לאחר מכן מתחילה הלולאה המציבה את התנאי הבא: while count != 10.
תנאי זה אומר שכל עוד count לא שווה ל10 הלולאה מתקיימת, כלומר, True.
3. בשלב הבא נאמר למחשב להדפיס את קאונט- print(count). אבל הלולאה עוד לא נגמרה.
4. לבסוף, המחשב מתבקש, לאחר שהוא מדפיס את count, להוסיף 1 לכמה ש-count שווה. ובכך הערך של count עולה ב-1 כל פעם שהלולאה רצה עד שcount יהיה שווה ל10, דבר אשר יחזיר False ובעצם יעצור את הלולאה שם ולא ידפיס את 10.

while True:
    print("infinite loop")

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

לולאת for:

• לולאת for היא מבנה קוד בתכנות שמשמש לחזרה על סדרה של ערכים. ב-Python, לולאת for משמשת לרוב לעבור על אוסף של איברים (כמו רשימה, מחרוזת, טווח מספרים וכו') ולבצע פעולה על כל אחד מהם.

numbers = [1, 2, 3, 4, 5]
for number in numbers:
    print(number)

- בדוגמה זו נוכל לראות רשימה בשם numbers ולולאת for אשר מבצעת את הפעולה:
for number in numbers
פעולה זו אומרת כך: עובר כל number (כלומר עבור כל איבר שיהיה, לא משנה אם זה רשימת מספרין או לא) ב- numbers, תדפיס את number. מה שזה בעצם עושה זה לעבור על איבר ברשימה numbers ומדפיס אותו.

• מה הוא איטרטור (iterator)? כל datatype שאנחנו יכולים לעבור עליו באמצעות לולאות: רשימה, מחרוזת, טאפל, מילון, סט ועוד.

• דוגמאות:
  

  [1,2,3]
  "hello"
  range(1,3)  # This will create an iterator from the number 1 to 3
  

• עוד דוגמאות של for:

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

for i in range(1, 5):
    print(i)

string = "hello"
for c in string:
    print(c)

• רשימה של טאפלים:
  

  points = [(1,2), (3,4), (5,6)]
  for x, y in points:
      print(f"point: {x},{y}")
  

• הפונקציה המובנית enumerate:
  

  string = "hello"
  enumerated_string = enumerate(string)
  print(enumerated_string)  # Output: [(0,'h'), (1,'e'), (2,'l'), (3,'l'), (4,'o')]
  
  for index, char in enumerated_string:
      print(f"{index}: {char}")
  

• הפונקציה split עם for:
  

  string = "i am the best programmer!"
  words = string.split(" ")
  for word in words:
      print(word)
  

• לולאת for עם _:

• תזכורת: התו _ אינו עושה משהו ספציפי, זהו רק הסימון ללתו כללי, הקוד יעבוד בדיוק אותו דבר אם היינו רושמים x במקום _ .
  ```python
  for _ in range(2):
  print("hello")
  

  - לעבור על מילון עם הפונקציה `items`:
  - הפונקציה `items()` היא מתודה המשמשת על מילונים ב-Python. היא מחזירה רשימה של זוגות מפתח-ערך (key-value pairs) הנמצאים במילון. כל זוג מיוצג כ-tuple, כאשר האלמנט הראשון הוא המפתח והשני הוא הערך.
  ```python
  # Interating dictionary.items
  dictionary = {
                   "hello": "shalom",
                   "thanks": "toda",
                   "boy": "ben"
               } 
  dictionary.items()
  
  for x, y in dictionary.items():
      print(x, y)
  
  
  # will print: hello shalom
              # thanks toda
               # boy ben
  

סינטקס: break ו - continue:

• אנחנו יכולים לעצור לולאה באמצע עם break.

• הפקודה break היא כלי בתכנות המשמש ליציאה מיידית מלולאה (כמו for או while). כאשר הפקודה break מבוצעת בתוך לולאה, היא גורמת ללולאה להסתיים באופן מיידי, והביצוע של התוכנית ממשיך לאחר הלולאה, כלומר, המחשב מפסיק לקרוא את הלולאה.
  

  while True:
      action = input("Enter an action: ")
      if action == "quit":
          break
  
  # will output: Enter an action: until your input will be quit, which stops the loop. 
  

• אנחנו יכולים לדלג על איטרציה של לולאה עם continue.

• הפקודה continue משמשת בתוך לולאות (כמו for או while) כדי לדלג על ההמשך של האיטרציה הנוכחית ולעבור ישירות לאיטרציה הבאה. כלומר, כאשר הפקודה continue מבוצעת, הקוד שלאחריה בתוך גוף הלולאה לא יורץ, והלולאה תמשיך לאיטרציה הבאה שלה.
  

  for i in range(1,10):
      number = int(input("Enter a number: "))
      if number == 5:
          continue
      print(number)
  
  # will output: the loop will print any number you put in it unless the number is 5 which will couse it to ask for a number again, and not print 5. 
  

• שימו לב: יש פעמים ששימוש בbreak ו - continue יכול להפוך את הקוד שלך לפחות קריא ולא צפוי, בדרך כלל אנחנו לא נשתמש בkeywords הללו.

סקופ - scope

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

  for i in range(10):
      x = i
      print(i)
  
  print(x)
  

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