זרימת שליטה בפייתון

מאמר זה מסביר את זרימת השליטה בפייתון.

YouTube Video

משפט If בפייתון

משפט ה-if בפייתון הוא תחביר להתניה מותנית. הוא משמש לביצוע בלוק קוד אם תנאי מסוים מת evaluates ל-True (אמת).

תחביר בסיסי

משפט ה-if בפייתון עוקב בעיקרון אחרי המבנה הבא.

1x = 10
2
3if x > 5: # Check if the condition(x > 5) is True
4    # If the condition is True, execute this code block
5    print("x is greater than 5")

בדוגמה זו, "x גדול מ-5" יודפס אם המשתנה x גדול מ-5.

משפט else

שימוש ב-else אחרי משפט if מאפשר לך לציין קוד לביצוע כאשר התנאי הוא שקר.

1x = 3
2
3if x > 5:
4    print("x is greater than 5")
5else:
6    print("x is less than or equal to 5")

בדוגמה זו, התוצאה תהיה "x קטן או שווה ל-5".

משפט elif

אם אתה צריך לבדוק כמה תנאים, תוכל להשתמש ב-elif, שמשמעותו "else if".

1x = 5
2
3if x > 5:
4    print("x is greater than 5")
5elif x == 5:
6    print("x is equal to 5")
7else:
8    print("x is less than 5")

בדוגמה זו, "x שווה ל-5" יודפס.

הערות

• קולון (:) נדרש אחרי if, elif או else.
• בלוק הקוד שמבוצע כאשר תנאי הוא אמיתי צריך להיות מוזח. בפייתון, ההזחה הסטנדרטית היא בדרך כלל 4 רווחים, אבל כל מספר אחר של רווחים מקובל כל עוד אתם עקביים.
• ניתן להשתמש בכל ביטוי שמת evaluates לערך בוליאני כתנאי. משמעות הדבר היא שניתן להשתמש בביטויים מותנים בשילוב עם אופרטורים השוואתיים או לוגיים.

שליטה במיומנויות של משפט ה-if בפייתון מאפשרות להפעיל את זרימת התוכנית בצורה גמישה.

ענפים מותנים מרובים בפייתון

יש מספר דרכים לממש פונקציונליות דמוית switch בפייתון, בדומה למה שקיים בשפות אחרות. בפייתון, נהוג להשתמש במשפטי if-elif-else או במילונים כדי ליצור מבנים הדומים למשפט switch.

שיטה 1: הצהרת if-elif-else

הדרך הפשוטה ביותר היא להשתמש בהצהרת if-elif-else לצורך הסתעפות מותנית.

 1def switch_example(value):
 2    if value == 1:
 3        return "Value is one"
 4    elif value == 2:
 5        return "Value is two"
 6    elif value == 3:
 7        return "Value is three"
 8    else:
 9        return "Unknown value"
10
11print(switch_example(1))  # Output: Value is one
12print(switch_example(4))  # Output: Unknown value

שיטה 2: שימוש במילונים

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

 1def case_one():
 2    return "Value is one"
 3
 4def case_two():
 5    return "Value is two"
 6
 7def case_default():
 8    return "Unknown value"
 9
10def switch_example(value):
11    switch_dict = {
12        1: case_one,
13        2: case_two
14    }
15
16    # Use get() method to retrieve the corresponding function from the dictionary
17    # If the value is not found in the dictionary, use case_default as a fallback
18    return switch_dict.get(value, case_default)()
19
20print(switch_example(1))  # Output: Value is one
21print(switch_example(3))  # Output: Unknown value

שיטה 3: הצהרת match (Python 3.10 ומעלה)

הצהרת match הוצגה בגרסת Python 3.10. זו תחביר להתאמת תבניות המספק פונקציונליות דומה להצהרת switch.

 1def switch_example(value):
 2    match value:
 3        case 1:
 4            return "Value is one"
 5        case 2:
 6            return "Value is two"
 7        case 3:
 8            return "Value is three"
 9        case _:
10            return "Unknown value"
11
12print(switch_example(1))  # Output: Value is one
13print(switch_example(4))  # Output: Unknown value

סיכום

• הצהרת if-elif-else: פשוטה וניתנת להתאמה למקרים רבים.
• מילונים: השתמש במיפויים של פונקציות או ערכים להפעלת הסתעפות יעילה.
• הצהרת match: מאפשרת הסתעפות אינטואיטיבית יותר ב-Python 3.10 ומעלה. הכי קרוב להצהרת switch.

לולאות for ב-Python

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

1# Loop through each item in the iterable
2for variable in iterable:
3    # Execute this block of code for each item in the iterable
4    code_to_execute

להלן כמה דוגמאות ספציפיות:.

דוגמה לשימוש ברשימה

1fruits = ["apple", "banana", "cherry"]
2for fruit in fruits:
3    print(fruit)

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

דוגמה לשימוש ב-range()

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

1for i in range(5):
2    print(i)

range(5) מייצרת מספרים שלמים מ-0 עד 4. במקרה זה, 0, 1, 2, 3, 4 יופלטו בסדר עוקב.

דוגמה לשימוש במילון

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

1person = {"name": "Alice", "age": 25}
2for key in person:
3    print(key, person[key])

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

1person = {"name": "Alice", "age": 25}
2for key, value in person.items():
3    print(key, value)

לולאת for מקוננת

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

1matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
2for row in matrix:
3    for num in row:
4        print(num)

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

continue לדלג על חזרה ו-break לסיים את הלולאה

שימוש ב-continue בתוך לולאת for ידלג על החזרה הנוכחית ויעבור לחזרה הבאה. בנוסף, שימוש ב-break יסיים לגמרי את הלולאה.

1for i in range(10):
2    if i == 5:
3        continue
4    if i == 8:
5        break
6    print(i)

בדוגמה זו, הלולאה מדלגת כאשר i שווה ל-5 ומסתיימת כאשר i שווה ל-8. לכן, הפלט יהיה 0, 1, 2, 3, 4, 6, 7.

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

לולאת while בפייתון

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

1while condition:
2    # This block of code will be executed repeatedly as long as the condition is true
3    statement1
4    statement2
5    ...

דוגמה:

בדוגמה הבאה, נעשה שימוש בלולאת while כדי להציג את המספרים מ-1 עד 5.

1i = 1
2while i <= 5:
3    print(i)
4    i += 1

הקוד הזה פועל כך.

• התחל עם i כ-1, הדפס את i כל עוד הוא קטן או שווה ל-5, והגדל את i ב-1 כל פעם.

הערה:

יש לשים לב לנקודות הבאות בעת שימוש ב-while.

1. היזהרו מלולאות אינסופיות

   • אם התנאי בלולאת while תמיד נכון (True), זה יוביל ללולאה אינסופית. יש לבצע פעולות מתאימות לשינוי התנאי; אחרת התוכנית לא תעצור.

2. שימוש ב-break וב-continue:

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

דוגמה ל-break:

1i = 1
2while i <= 5:
3    if i == 3:
4        break  # Exit the loop when i becomes 3
5    print(i)
6    i += 1

• במקרה זה, לאחר שהמספרים 1 ו-2 מוצגים, הלולאה מסתיימת כאשר i הופך ל-3.

דוגמה ל-continue:

1i = 0
2while i < 5:
3    i += 1
4    if i == 3:
5        # Skip the print statement and move to the next loop iteration when i is 3
6        continue
7    print(i)

• במקרה זה, המידע מדולג רק עבור 3, והתוצאה היא 1, 2, 4, 5.
• על ידי הגדלת הערך של i בתחילת הלולאה, המונה מתקדם גם אם מופעל continue, כך שנמנעת לולאה אינסופית.

תוכלו לעקוב אחר המאמר שלמעלה באמצעות Visual Studio Code בערוץ היוטיוב שלנו. נא לבדוק גם את ערוץ היוטיוב.

YouTube Video