עבור לולאה בפייתון
הצהרת לולאה ב- Python חוזרת ברצף על פני כל אובייקט, רשימה, מחרוזת וכו '. בהשוואה לשפות תכנות אחרות, התחביר שלה הרבה יותר נקי ואינו דורש הגדרה ידנית של שלבי איטרציה והפעלת איטרציה. למרות שישנן דרכים להפוך את התנהגותה להיות זהה לשפות תכנות אחרות (לא יוסבר במאמר זה). תוכל גם להפעיל שליטה מסוימת על לולאות באמצעות הצהרות כמו המשך, הפסקה, מעבר וכו 'להלן דוגמה פשוטה של לולאה ב- Python:
לאיקסב טווח(10):
הדפס(איקס)
לולאת ה- for למעלה תדפיס עשרה מספרים החל מ -0 וכלה ב -9.
רשימת הבנות
הבנת רשימות אינה אלא דרך קצרה / תמציתית לכתוב ריבוי שורות ללולאות בהצהרה של שורה אחת. הדוגמה להבנת הרשימות להלן תיצור רשימה חדשה בשם [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] על ידי הכללת כל הערכים של x בה.
מספרים= [איקסלאיקסב טווח(10)]
הדפס (מספרים)
שים לב שהבנת הרשימות יוצרת תמיד רשימה חדשה ואינה משנה את הגורמים המקוריים שבהם נעשה שימוש בביטוי. ביטוי טיפוסי להבנת רשימה חייב להיות בעל סעיף עבור ואפשר לעקוב אחריו אם ועוד הצהרות מותנות. מבלי להשתמש בהבנת רשימה, הדוגמה לעיל תיכתב באופן הבא:
מספרים= []
לאיקסב טווח(10):
מספרים.לְצַרֵף(איקס)
הדפס (מספרים)
ביצועים וקריאות
הבנת הרשימות מהירה יותר מאשר לולאות. עם זאת, אלא אם כן אתה חוזר על מאות אלפי פריטים, לא תבחין בשיפורי ביצועים גדולים. בעוד שהבנת הרשימות מספקת דרך תמציתית לכתוב עבור לולאות, ביטויים מורכבים יכולים להוביל לקריאות לקויה של קוד ולהגדלת ורבוליות. חשוב לשמור על קוד קריאה, אלא אם כן השגת ביצועים מקסימליים היא הכרח מוחלט לתוכנית שלך.
דוגמה: שימוש בתחביר ההבנות ברשימה עם מילונים וערכים
מילון פייתון הוא אוסף של אלמנטים המוגדרים בזוגות ערך-מפתח ואילו קבוצה היא אוסף של ערכים ייחודיים שבהם אין להכפיל כפילויות. ניתן להשתמש בהבנת רשימות גם במילוני ומערכות פייתון. התחביר שונה במקצת, במקום לעטוף את הביטוי בסוגרים מרובעים, כעת יהיה עליך להשתמש בסוגרים מתולתלים. תקבל גם מילון / אובייקט סט חדש במקום רשימה חדשה.
נתונים= {'עִיר':'ניו יורק', 'שֵׁם':'פלוני אלמוני'}
נתונים_פורמט= {k: v.כותרת() לל,vבנתונים.פריטים()}
הדפס (נתונים_פורמט)
הדוגמה שלמעלה תמיר ערכי מחרוזת לכותרת אותיות ותיצור מילון חדש בשם formatted_data, שפלטו יהיה: {'city': 'New York', 'name': 'John Doe'}. תוכל גם לשנות את המילון / הגדרה במקום על ידי ציון משתנה המילון הקיים בצד שמאל.
נתונים= {'עִיר':'ניו יורק', 'שֵׁם':'פלוני אלמוני'}נתונים= {k: v.כותרת() לל,vבנתונים.פריטים()}
הדפס (נתונים)
ללא שימוש בהבנות מילון, הקוד ייראה כך:
נתונים= {'עִיר':'ניו יורק', 'שֵׁם':'פלוני אלמוני'}נתונים_פורמט= {}
לל,vבנתונים.פריטים():
נתונים_פורמט[ל] =v.כותרת()
הדפס (נתונים_פורמט)
מכיוון שאין זוגות ערך-מפתח בערכים, ניתן להגדיר תפיסת קבוצה באותו אופן כמו הבנת רשימה. ההבדל היחיד הוא השימוש בסדים מתולתלים.
דוגמה: ריבוי לולאות בהבנת רשימה
הדוגמה להבנת הרשימות שהוזכרה לעיל הינה בסיסית ומשתמשת בהצהרה אחת. להלן דוגמה שמשתמשת במספר לולאות והצהרה מותנית אם.
שמות תואר= ['דִיסק', 'איאן', 'מוֹקְדִי', 'עַרמוּמִי']חיות= ['דינגו', 'סַמוּר', 'הבור', 'בונה']
שמות קודים= [x +''+ ולאיקסבשמות תוארלובחיותאםו.מתחיל עם(איקס[0])]
הדפס (שמות קודים)
הקוד יציג ['דיסקו דינגו', 'Eoan Ermine', 'Focal Fossa'] כפלט. שני הלולאות עוברים על תארים ורשימות בעלי חיים וחבריהם מחוברים יחד באמצעות רווח, רק אם האות הראשונה בשתי המילים זהה. ללא שימוש בהבנות רשימה, הקוד ייראה כך:
שמות תואר= ['דִיסק', 'איאן', 'מוֹקְדִי', 'עַרמוּמִי']חיות= ['דינגו', 'סַמוּר', 'הבור', 'בונה']
שמות קודים= []
לאיקסבשמות תואר:
לובחיות:
אםו.מתחיל עם(איקס[0]):
שמות קודים.לְצַרֵף(x +''+ ו)
הדפס (שמות קודים)
דוגמה: רשימת הבנת רשימות עם סעיף אם-אחר
הדוגמה להלן תציג שימוש בהצהרות if ועוד בהבנות רשימה.
מספר_רשימה= [1, 2, 3, 4]עוד_רשימה= [5, 6, 7, 8]
תוֹצָאָה= [נָכוֹן אם (x + y)%2 == 0 אַחֵר שֶׁקֶר לאיקסבמספר_רשימהלובעוד_רשימה]
הדפס (תוֹצָאָה)
בעת עיון בשתי רשימות, הבנת הרשימות שלמעלה בודקת אם סכום צמד האלמנטים שווה או לא. הפעלת הקוד למעלה תראה לך [נכון, שקר, נכון, שקר, שקר, נכון, שקר, נכון, נכון, שקר, נכון, שקר, שקר, נכון, שקר, נכון] כפלט. ללא שימוש בהבנת רשימה, הקוד ייראה כך:
מספר_רשימה= [1, 2, 3, 4]עוד_רשימה= [5, 6, 7, 8]
תוֹצָאָה= []
לאיקסבמספר_רשימה:
לובעוד_רשימה:
אם (x + y)%2 == 0:
תוֹצָאָה.לְצַרֵף(נָכוֹן)
אַחֵר:
תוֹצָאָה.לְצַרֵף(שֶׁקֶר)
הדפס (תוֹצָאָה)
סיכום
הבנת רשימות מספקת דרך נחמדה לכתוב הצהרות לולאה נקיות ותמציתיות. עם זאת, הם יכולים להפוך במהירות למורכבים וקשים להבנה אם משתמשים במספר לולאות והצהרות מותנות. בסופו של דבר, זה מגיע לרמת הנוחות של מתכנת אבל באופן כללי זה רעיון טוב לכתוב קוד מפורש, קריא וקל לניפוי באגים במקום להשתמש בקצרה.