תוך לולאה בפייתון. איך זה עובד, דוגמאות לשימוש

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

הרעיון של מחזור

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

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

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

מחזור עבור

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

היתרון של הלולאה הזו ב-Python הוא שלא צריך לקבוע את האינדקס של האלמנט כדי לדעת מתי לצאת מהלולאה. הכל יתבצע אוטומטית.

>>> spisok = [10, 40, 20, 30]

>>> עבור אלמנט ב-spisok:

… print(אלמנט + 2)

...

12

42

22

32

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

במקרה שלנו, הרשימה היא רצף של מספרים 10,40,20,30. בכל איטרציה מופיע הערך המתאים במשתנה. לדוגמה, ברגע שהלולאה מתחילה, המשתנה אלמנט הערך 10 מוקצה. באיטרציה הבאה, העשר הופך למספר 40, בפעם השלישית הוא הופך למספר 20, ולבסוף, באיטרציה האחרונה של הלולאה, הוא הופך ל-30.

האות לסיום המחזור הוא סוף האלמנטים ברשימה.

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

>>> spisok = [1,2,3,4,5]

או השתמש בפונקציה לן(), כדי לקבוע את אורך הרשימה. אבל במקרה זה עדיף להשתמש בלולאה בזמן, כי אין צורך להשתמש במשתנה.

אם אתה צריך לשנות את רצף הערכים ברשימה, לולאה ל והנה בא להצלה. לשם כך, בכל איטרציה יש להקצות לכל רכיב ברשימה ערך מתאים.

בעוד לולאה

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

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

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

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

מחזור בזמן יכול לגרום לשני חריגים:

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

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

בעוד לולאה דוגמאות

הנה דוגמה לקוד שמטפל בשגיאה במקרה זה.

n = input("הזן מספר שלם: ") 

בעוד סוג(n) != int:

    לנסות:

        n = int(n)

    למעט ValueError:

        print(“ערך שגוי!”)

        n = input("הזן מספר שלם: ") 

אם n % 2 == 0:

    print ("אפילו")

else

    print ("מוזר")

זכור ש-Python משתמש בנקודתיים כדי להכריז על בניית קוד מורכב.

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

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

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

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

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

ניתוח קוד

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

1. ראשית, המשתמש מזין מחרוזת, שמתקבלת על ידי המשתנה n. 
2. באמצעות לולאה בזמן סוג המשתנה הזה מסומן. בכניסה הראשונה, זה לא שווה int. לפיכך, כתוצאה מהבדיקה נמצא כי מצב זה נכון. לכן, נכנס גוף הלולאה.
3. בעזרת מפעיל לנסות אנחנו מנסים להמיר מחרוזת למספר. אם זה נעשה, אז לא מתרחשת שגיאה. לפיכך, אין צורך בעיבודו. לכן, המתורגמן חוזר לתחילת הלולאה, ולפי תוצאות הבדיקה מתברר שהוא הפך למספר שלם. אז בואו נעבור לשלב 7
4. אם ההמרה לא הצליחה, נזרק ValueError. במקרה זה, זרימת התוכנית נשלחת למטפל למעט.
5. המשתמש מזין ערך חדש, אשר מוקצה למשתנה n.
6. המתורגמן חוזר לשלב 2 ובודק שוב. אם זה ערך של מספר שלם, עבור לשלב 7. אם לא, ניסיון ההמרה שוב בהתאם לשלב 3.
7. בעזרת מפעיל if קובע אם יש שארית לאחר חלוקת מספר ב-2. 
8. אם לא, הטקסט "אפילו" מוחזר.
9. אם לא, הטקסט "מוזר" מוחזר.

שקול עכשיו דוגמה כזו. נסה לקבוע כמה פעמים המחזור הזה יעבור?

סך הכל = 100 

i = 0

בזמן שאני <5:

    n = int(input())

    סך = סך - נ

    i = i + 1 

print("נותר", סך הכל)

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

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

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

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

סך הכל = 100 

בעוד סה"כ > 0:

    n = int(input())

    סך = סך - נ 

print("המשאב נגמר")

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

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