לולאת Python

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

פונקציונליות של לולאת for אינה מאוד שונה ממה שאתה רואה בשפות תכנות רבות אחרות.

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

מתי להשתמש בלולאת for

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

תחביר לולאת for בפייתון

התחביר הבסיסי של לולאת for בפייתון נראה משהו דומה לזה שהוזכר למטה.

for itarator_variable in sequence_name:
	Statements
	. . .
	Statements

תחביר של לולאת for ב-Python בפרטיות

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

הדפסת אותיות יחידות של מחרוזת באמצעות הלולאה for

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

הנה כיצד זה יעבוד בשבילך.

word="anaconda"
for letter in word:
	print (letter)

פלט:

a
n
a
c
o
n
d
a

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

בשימוש בלולאת for לעבור על רשימה או טופל בפייתון

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

words= ["Apple", "Banana", "Car", "Dolphin" ]
for word in words:
	print (word)

פלט:

Apple
Banana
Car
Dolphin

עכשיו, בואו נמשיך ונעבוד על לולאה מעל איברי טופל כאן.

nums = (1, 2, 3, 4)

sum_nums = 0

for num in nums:
    sum_nums = sum_nums + num

print(f'Sum of numbers is {sum_nums}')

# פלט
# סכום המספרים הוא 10

הקניית תווי פייתון

כאשר יש לנו לולאה for בתוך לולאה אחרת for, זה נקרא לולאה מקוננת. ישנם שימושים מרובים של לולאה מקוננת.

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

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

words= ["Apple", "Banana", "Car", "Dolphin" ]
for word in words:
        # הלולאה הזו מחזירה מילה מהרשימה
        print ("The following lines will print each letters of "+word)
        for letter in word:
                # הלולאה הזו מחזירה אות למילה
                print (letter)
        print("") # ההדפס הזה משמש להדפיס שורה ריקה

פלט

A nested loop is structurally similar to nested if statements

לולאת for של פייתון עם פונקציית range()

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

כאשר אתה עובד עם range(), אתה יכול למסור בין 1 ל־3 ארגומנטים שלמים אליה:

• start מציין את הערך השלם ממנו מתחילה הרצף, אם זה אינו נכלל אז start מתחיל ב־0
• stop נדרש תמיד והוא המספר השלם שסופרים עד אליו אך לא כולל אותו
• שלב מגדיר כמה להגדיל (או להפחית במקרה של מספרים שליליים) את האיטרציה הבאה, אם זה נושא בלתי מוגדר אז שלב מוגדר בברירת מחדל ל- 1

שקול לדוגמה הבאה בה אני רוצה להדפיס את המספרים 1, 2 ו- 3:

for x in range(3):
    print("Printing:", x)
	
# פלט

# הדפסה: 0
# הדפסה: 1
# הדפסה: 2

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

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

for n in range(1, 10, 3):
    print("Printing with step:", n)
	
# פלט

# הדפסה עם שלב: 1
# הדפסה עם שלב: 4
# הדפסה עם שלב: 7

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

for i in range(100,0,-10):
   print(i)

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

Output
100
90
80
70
60
50
40
30
20
10

כאשר מתכנתים ב-Python, לולאות for נהוגות להשתמש בסוג הרצף range() כפרמטרים שלהן לצורך חזרה.

הצהרת ה-break עם לולאת for

ההצהרה break משמשת לצאת מהלולאה for מוקדם. היא משמשת לשבור את הלולאה for כאשר תנאי מסוים מתקיים.

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

במקרה זה, נשתמש בתנאי if else של Python יחד עם הלולאה שלנו.

nums = [1, 2, 3, 4, 5, 6]

n = 2

found = False
for num in nums:
    if n == num:
        found = True
        break

print(f'List contains {n}: {found}')

# פלט
# הרשימה מכילה 2: נכון

הצהרת ה-continue עם לולאת for

ניתן להשתמש בהצהרות continue בתוך לולאה for כדי לדלג על ביצוע גוף הלולאה for עבור תנאי מסוים.

בואו נניח שיש לנו רשימת מספרים ורוצים להדפיס את סכום המספרים החיוביים. נוכל להשתמש בהצהרת continue כדי לדלג על הלולאה for עבור המספרים השליליים.

nums = [1, 2, -3, 4, -5, 6]

sum_positives = 0

for num in nums:
    if num < 0:
        continue
    sum_positives += num

print(f'Sum of Positive Numbers: {sum_positives}')

לולאת for בפייתון עם בלוק else

נוכל להשתמש בבלוק else עם לולאת for בפייתון. הבלוק else מבוצע רק כאשר ה-לולאה for אינה מסתיימת באמצעות הצהרת break.

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

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

def print_sum_even_nums(even_nums):
    total = 0

    for x in even_nums:
        if x % 2 != 0:
            break

        total += x
    else:
        print("For loop executed normally")
        print(f'Sum of numbers {total}')


# זה ידפיס את סכום המספרים
print_sum_even_nums([2, 4, 6, 8])

# זה לא ידפיס את סכום המספרים בשל מספר אי-זוגי בסדרה
print_sum_even_nums([2, 4, 5, 8])

# פלט

# לולאת for בוצעה באופן רגיל
# סכום המספרים הוא 20

לולאות for בשימוש בסוגי נתונים סדרתיים

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

נשייך רשימה למשתנה, ואז נעבור דרך הרשימה:

sharks = ['hammerhead', 'great white', 'dogfish', 'frilled', 'bullhead', 'requiem']

for shark in sharks:
   print(shark)

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

Output
hammerhead
great white
dogfish
frilled
bullhead
requiem

הפלט לעיל מראה שהלולאת for עברה דרך הרשימה, והדפיסה כל פריט מהרשימה בכל שורה.

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

sharks = ['hammerhead', 'great white', 'dogfish', 'frilled', 'bullhead', 'requiem']

for item in range(len(sharks)):
   sharks.append('shark')

print(sharks)

Output
['hammerhead', 'great white', 'dogfish', 'frilled', 'bullhead', 'requiem', 'shark', 'shark', 'shark', 'shark', 'shark', 'shark']

כאן, הוספנו מחרוזת מקום כללית של 'shark' לכל פריט באורך הרשימה sharks.

ניתן גם להשתמש בלולאת for כדי לבנות רשימה מאפס:

integers = []

for i in range(10):
   integers.append(i)

print(integers)

בדוגמה זו, הרשימה integers מאותחלת כריקה, אך הלולאה for ממלאה את הרשימה כך:

Output
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

באופן דומה, ניתן לעבור דרך מחרוזות:

sammy = 'Sammy'

for letter in sammy:
   print(letter)

Output
S
a
m
m
y

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

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

sammy_shark = {'name': 'Sammy', 'animal': 'shark', 'color': 'blue', 'location': 'ocean'}

for key in sammy_shark:
   print(key + ': ' + sammy_shark[key])

Output
name: Sammy
animal: shark
location: ocean
color: blue

כאשר משתמשים במילונים עם for לולאות, המשתנה שמעביר על הערכים נקודתי למפתחות של המילון, ו- dictionary_variable[iterating_variable] מתאים לערכים. במקרה הנ״ל, המשתנה שמעביר על הערכים key נעשה שימוש כדי לייצג את המפתח, ו- sammy_shark[key] נעשה שימוש כדי לייצג את הערכים.

לולאות בדרך כלל משמשות לעבור ולשנות סוגי נתונים רצופים.

מסקנה

הלולאה for בפייתון דומה מאוד לשפות תכנות אחרות. ניתן להשתמש בהצהרות ה-break וה-continue עם לולאה for כדי לשנות את הביצוע. אולם, בפייתון, ניתן גם להשתמש בחסום else אופציונלי בלולאה for.

I hope you have gained some interesting ideas from the tutorial above. If you have any questions, let us know in the comments below.

מכאן, ניתן להמשיך ללמוד על לולאות על ידי קריאת מדריכים על לולאות while ו-הצהרות break, continue ו- pass.

כדי לעבוד עם לולאות for בפרויקטים, עקוב אחר המדריכים הבאים:

• איך ליצור Twitterbot עם Python 3 וספריית Tweepy
• איך לעבוד עם נתוני שפה ב-Python 3 באמצעות הספרייה NLTK
• איך ליצור תדר של תדרי מילים בעזרת matplotlib עם Python 3