Generic selectors
Exact matches only
Search in title
Search in content
Search in posts
Search in pages

קורס Python – פרק 7 – לולאות Loops

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

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

 

לולאות Loops

 

שפת 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+ לספירה.

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

The count is: 0
The count is: 1
The count is: 2
The count is: 3
The count is: 4
The count is: 5
The count is: 6
The count is: 7
The count is: 8
!Good bye

 

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

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


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

print ("Good bye!")

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

Enter a number :5
You entered: 5
Enter a number :6
You entered: 6
Enter a number :7
You entered: 7
Enter a number :8
You entered: 8
Enter a number :9
You entered: 9

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

 : Enter a number
:(Traceback (most recent call last
File "D:/ptn/infinite.py", line 3, in
((":   num = int(input("Enter a number
KeyboardInterrupt
<<<

 

שימוש בביטויי 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 שכל עוד התנאי הוא אמת היא חוזרת על עצמה ומדפיסה לנו הודעה, עד אשר התנאי הופך להיות כזב ואז נקבל הודעה אחרת, כפי שניתן לראות בפלט שקיבלנו כאשר הרצנו את התוכנית:

0is less than 3
1is less than 3
2is less than 3
3is not less than 3

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

בדומה למשפטי 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
1
2
3
4

שימו לב שהספרה הראשונה ברצף היא 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)

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

Current Letter : P
Current Letter : y
Current Letter : t
Current Letter : h
Current Letter : o
Current Letter : n

Current fruit : banana
Current fruit : apple
Current fruit : mango

 

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

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


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

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

Current fruit : banana
Current fruit : apple
Current fruit : mango

 

שימוש בביטויי 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, כפי שניתן לראות בפלט שקיבלנו:

the list doesnot contain even number

 

שרשור לולאות

שפת 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 שגורם לכך שיהיה רווח במקום שירד שורה, כך שמכפלות של אותו מספר יוצגו בשורה אחת.

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

1 2 3 4 5 6 7 8 9 10
2 4 6 8 10 12 14 16 18 20
3 6 9 12 15 18 21 24 27 30
4 8 12 16 20 24 28 32 36 40
5 10 15 20 25 30 35 40 45 50
6 12 18 24 30 36 42 48 54 60
7 14 21 28 35 42 49 56 63 70
8 16 24 32 40 48 56 64 72 80
9 18 27 36 45 54 63 72 81 90
10 20 30 40 50 60 70 80 90 100

 

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

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

Break

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

 

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")

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

Current Letter : P
Current Letter : y
Current Letter : t
Current variable value : 10
Current variable value : 9
Current variable value : 8
Current variable value : 7
Current variable value : 6
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')

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

any number: 11
number found in list

any number: 6
number not found in list

 

Continue

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

 

Continue

 

לדוגמה:


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)

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

Current Letter : P
Current Letter : y
Current Letter : t
Current Letter : o
Current Letter : n
Current variable value : 9
Current variable value : 8
Current variable value : 7
Current variable value : 6
Current variable value : 4
Current variable value : 3
Current variable value : 2
Current variable value : 1
Current variable value : 0

 

Pass

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


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

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

Current Letter : P
Current Letter : y
Current Letter : t
This is pass block
Current Letter : h
Current Letter : o
Current Letter : n

 

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)

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

1
2
3
4

 

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. כאשר נריץ תכנית זו יתקבל הפלט הבא:

0 1 1 2 3 5

רוצים לשתף את המדריך?

שיתוף ב facebook
שיתוף ב twitter
שיתוף ב telegram
שיתוף ב whatsapp
שיתוף ב linkedin
שיתוף ב tumblr
שיתוף ב email
שיתוף ב reddit
שיתוף ב skype
שיתוף ב vk

אהבתכם את המדריך? פתר לכם תקלה?

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

כתיבת תגובה