מדריך Python – פרק 7 – לולאות Loops

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

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

 

 

שפת Python תומכת ב-3 סוגי לולאות:

 

לולאת while Loop

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

while expression:
   statement(s)

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

count = 0
while (count < 9):
   print ('The count is:', count)
   count = count + 1

print ("Good bye!")

בלוק הקוד שניתן לראות בתוכנית זו מכיל את הביטוי print ואת ביטוי החיבור שנמצא במשפט שמתחתיו, כאשר בלוק קוד זה ירוץ כל עוד מספר הפעמים שהלולאה חזרה על עצמה הוא קטן מ-9. כלומר שבכל פעם שהלולאה חוזרת על עצמה, היא מדפיסה את מספר הפעמים שחזרה על עצמה ומוסיפה 1+ לספירה.

כאשר נריץ את התוכנית נקבל את התוצאה הבא:

 

לולאה אינסופית

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

var = 1
while var == 1 :  # This constructs an infinite loop
   num = int(input("Enter a number  :"))
   print ("You entered: ", num)

print ("Good bye!")

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

ועל מנת לצאת מהתכנית יש להקיש את צירוף המקשים Ctrl + C, ואז התכנית תישבר ונקבל את הפלט הבא:

 

שימוש בביטויי Else בלולאות While

שפת Python תומכת בשימוש בביטויי else בלולאות, אם ביטוי ה-else מגיע אחרי לולאת While Loop, אז ביטוי ה-else יצא לפועל כאשר התנאי הוא כזב.

בתוכנית הבאה נדגים לולאת while loop אשר משולבת עם ביטוי else:

count = 0
while count < 3:
   print (count, " is  less than 3")
   count = count + 1
else:
   print (count, " is not less than 3")

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

לולאות במערכת של משפט בודד

בדומה למשפטי If, גם לולאות While ניתן לכתוב בשורה בודדת כאשר מדובר בגוף לולאה בעל משפט בודד כפי שניתן לראות בדוגמה הבאה:

count = 1
while (count): print ((count))

תוכנית זו שהיא למעשה הדגמה של לולאה אינסופית במשפט בודד, תדפיס ללא הפסקה את הערך של משתנה count, ועל מנת לצאת ממנה יש להקיש את צירוף המקשים Ctrl + C.

לולאת For Loop

לולאות For Loops מאפשרות לנו לחזור על פריטים של רצף נתון, כמו רשימת מחרוזות למשל. זהו התחביר הנכון ללולאת for:

for iterating_var in sequence:
statements(s)

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

הפונקציה ( )range

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

for var in list(range(5)):
print (var)

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

שימו לב שהספרה הראשונה ברצף היא 0 ולכן הספרה 4 תהיה הפריט האחרון ברצף ()range בן 5 פריטים כפי שהגדרנו.

דוגמאות נוספות:

for letter in 'Python': # traversal of a string sequence
print ('Current Letter :', letter)
print()
fruits = ['banana', 'apple', 'mango']

for fruit in fruits: # traversal of List sequence
print ('Current fruit :', fruit)

שיתנו לנו את הפלט הבא:

 

חזרה על רצף על ידי שימוש באינדקס 

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

fruits = ['banana', 'apple', 'mango']
for index in range(len(fruits)):
print ('Current fruit :', fruits[index])

שכאשר נריץ תוכנית זו נקבל את התוצאה הבאה:

 

שימוש בביטויי Else בלולאות For

שפת Python תומכת בשימוש בביטויי else בלולאות, אם ביטוי ה-else מגיע אחרי לולאת For Loop, אז ביטוי ה-else יצא לפועל אחרי שהתוכנית תסיים לעבור על כל הרצף הנתון, לדוגמה:

numbers = [11,33,55,39,55,75,37,21,23,41,13]

for num in numbers:
if num%2 == 0:
print ('the list contains an even number')
break
else:
print ('the list doesnot contain even number')

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

 

שרשור לולאות

שפת Python מאפשרת שימוש של לולאה בתוך לולאה,  כמו כן ניתן לשים לולאת for בתוך לולאת while ולהיפך.

זהו התחביר הנכון לכתיבת לולאות בשרשור:

while expression:
while expression:
statement(s)
statement(s)

בתוכנית הבאה נשתמש בשרשור לולאות על מנת להציג מכפלות של מספרים מ-1 עד 10:

for i in range(1,11):
for j in range(1,11):
k = i*j
print (k, end=' ')
print()

שימו לב כי בפונקציית ה-()print הראשונה השתמשנו בסימן המיוחד ' '=end שגורם לכך שיהיה רווח במקום שירד שורה, כך שמכפלות של אותו מספר יוצגו בשורה אחת.

כאשר נריץ תכנית זו נקבל את התוצאה הבאה:

 

משפטי שליטה בלולאות Break, Continue, Pass

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

Break

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

 

לדוגמה:

for letter in 'Python': # First Example
if letter == 'h':
break
print ('Current Letter :', letter)

var = 10 # Second Example
while var > 0:
print ('Current variable value :', var)
var = var -1
if var == 5:
break

print ("bye")

וכאשר נריץ תוכנית זו נקבל את התוצאה הבאה:

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

no = int(input('any number: '))
numbers = [11,33,55,39,55,75,37,21,23,41,13]

for num in numbers:
if num == no:
print ('number found in list')
break
else:
print ('number not found in list')

ולכן נקבל את הפלט הבא:

 

Continue

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

 

 

לדוגמה:

for letter in 'Python': # First Example
if letter == 'h':
continue
print ('Current Letter :', letter)

var = 10 # Second Example
while var > 0:
var = var -1
if var == 5:
continue
print ('Current variable value :', var)

וכאשר נריץ תוכנית זו נקבל את התוצאה הבאה:

 

Pass

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

for letter in 'Python':
if letter == 'h':
pass
print ('This is pass block')
print ('Current Letter :', letter)

וכאשר נריץ תוכנית זו נקבל את התוצאה הבאה:

 

Iterator ו-Generator

Iterator הוא אובייקט המאפשר למתכנת לעבור על האלמנטים של אוסף שלם. יש שתי שיטות לאובייקטי iterIterator שהן השיטות ()iter ו-()next. ניתן להשתמש באובייקטי String, List או Tuple על מנת ליצור Iterator:

list = [1,2,3,4]
it = iter(list)
print (next(it))
for x in it:
print (x)

וכאשר נריץ תוכנית זו נקבל את התוצאה הבאה:

 

Generator היא פונקציה אשר יוצרת רצף של ערכים עם שיטת yield. כאשר הפונקציה נקראת, נוצר אובייקט Generator עוד לפני שהפונקציה יוצאת לפועל. כאשר שיטת ה-()next נקראת בפעם הראשונה, הפונקציה יוצאת לפועל עד אשר היא נתקלת במשפט ה-yield, שמחזירה את רצף הערכים. ה-yield זוכר את ההרצה הראשונה, כך שהלולאה תגיע לשיטת ה-()next בפעם השנייה תמשיך מהערך הקודם.

בתוכנית הבאה ניצור Generator אשר יוצר רצף של מספרי פיבונאצ'י:

import sys
def fibonacci(n): #generator function
a, b, counter = 0, 1, 0
while True:
if (counter > n):
return
yield a
a, b = b, a + b
counter += 1
f = fibonacci(5) #f is iterator object

while True:
try:
print (next(f), end=" ")
except StopIteration:
sys.exit()

שימו לב שנהיה חייבים להתחיל את התכנית במשפט import sys ולסיים במשפט ()sys.exit. כאשר נריץ תכנית זו יתקבל הפלט הבא: