כיצד להשתמש לולאה בפייתון

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

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

איך לולאות עובדות בפייתון

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

א ל לולאה יש מאפיינים דומים בכל שפות התכנות. לדוגמא, בעוד שיש הבדלי תחביר, ה- מאפיין של Java עבור לולאה דומה לאופן שבו פועל הלולאה של פייתון.

כיצד לכתוב לולאה ב- Java

למד כיצד להשתמש בלולאות, אחת הכישורים השימושיים ביותר לשליטה בתכנות למתחילים.

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

עבור חדש_משתנה בהורה_שנות:
לבצע כמה הצהרות

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

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

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

אם אין בהצהרה שלעיל אַחֵר מצב, אז לא היית כותב כלום. זה אומר שזה מערך ריק.

כיצד להשתמש ב- Python's for Loop: דוגמאות מעשיות

עכשיו בואו נסתכל על כמה דוגמאות מעשיות לאופן השימוש ב- ל לולאה בפייתון.

קטע הקוד שלמטה מוציא כל אחד מהפריטים ברשימה:

פריטים = ["נעל", "תיק", "חולצות", "מנורה"]
עבור אני בפריטים:
הדפס (i)

אתה יכול גם לשנות את הקוד לעיל כדי להוציא כל פריט שיש לו את האות "a":

פריטים = ["נעל", "תיק", "חולצות", "מנורה"]
עבור אני בפריטים:
אם "a" ב- i: 
הדפס (i)

א ל לולאה בפייתון לוקח גם ישירות אַחֵר הַצהָרָה:

b = [2, 3, 5, 6]
עבור אני ב:
הדפס (i)
אַחֵר:
הדפס ("לולאה הסתיימה")

אתה יכול להשתמש ב- לשבור הצהרה לשינוי זרימת א ל לולאה גם כן:

b = [2, 3, 5, 6]
עבור אני ב:
אם אני> 3:
לשבור
הדפס (i)

אתה יכול גם להשתמש ב- לְהַמשִׁיך מילת מפתח עם ל לוּלָאָה:

b = [2, 3, 5, 6]
עבור אני ב:
אם אני> 3:
לְהַמשִׁיך
הדפס (i)

שימוש ב- Loop עם רשימה וספרות מיתרים בפייתון

עכשיו תסתכל על הקוד שלמטה כדי להפיק את כל המספרים השלמים החיוביים שבין 1 ל 100. לשם כך, תחילה תיצור רשימה של מספרים בין 1 ל 100 באמצעות המובנה של Python טווח פוּנקצִיָה:

עבור x בטווח (1, 101):
הדפס (x)

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

עבור x בטווח (1, 101):
אם x% 2 == 1:
הדפס (x)

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

עבור x בטווח (1, 101):
אם x% 2 == 1:
הדפס (x, "x", 2, "=", x * 2)

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

הקוד שלמטה מחזיר רצף של כל מחרוזת במשפט:

a = "כיצד להשתמש ב- Loop ב- Python"
עבור אני ב:
הדפס (i)

אנו יכולים גם לספור את מספר המיתרים (כולל רווחים) במשתנה א באמצעות א ל לוּלָאָה:

a = ["כיצד להשתמש ב- Loop ב- Python"]
עבור אני ב:
הדפס (i.count (''))
תפוקה: 32

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

a = ["כיצד להשתמש ב- Loop ב- Python"]
c = [b.count ('') עבור b ב- a]
הדפס (ג)
פלט: [32]

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

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

a = ["כיצד להשתמש ב- Loop ב- Python"]
עבור אני ב:
הדפס (i.count ('') + 1)
תפוקה: 8

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

a = ["כיצד להשתמש ב- Loop ב- Python"]
c = [b.count ('') + 1 עבור b ב- a]
הדפס (ג)
פלט: [8]

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

קָשׁוּר: כיצד ליצור ולהשתמש מחדש במודול משלך בפייתון

שימוש בפייתון לולאה עם מערך

אתה יכול גם להשתמש ב- ל לולאה כדי להשיג אלמנט מסוים ממערך.

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

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

מערך = [{"name": "Sheep1", "healthy": "Yes"},
{"name": "Sheep3", "healthy": "No"}, 
{"name": "Sheep4", "healthy": "Yes"}, 
{"name": "Sheep5", "healthy": "Yes"}, 
{"name": "Sheep8", "healthy": "No"},
{"name": "Sheep7", "healthy": "No"},
{"name": "Sheep9", "healthy": "No"}
]
לכבשים במערך:
אם כבשים ["בריא"] == "לא":
הדפס ("הסגר", כבשים ["שם"])

שימוש ב- Nested For Loop בפייתון

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

nested_list = [[1, 2, 4, 5], {"name": "Python", "method": "write"}]
לתכתיב ברשימה המקוננת:
עבור אני בדיקט:
הדפס (i)

א הבנה טובה יותר של הרשימה והמערכים של פייתון שימושי כאשר מתמודדים עם מקונן ל לוּלָאָה.

עבור לולאות או בזמן לולאות, מה עדיף?

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

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

כיצד להשתמש בזמן לולאה בפייתון

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

על הסופר