משפט אם מותנה ב-Python. תחביר, else/elif blocks, דוגמאות

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

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

סוגי הצהרות בקרה

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

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

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

1. שוויון של משתנה לערך מסוים.
2. ביצוע פעולה ספציפית.
3. מצב יישום (ממוטט או לא).

הספקטרום יכול להיות הרבה יותר גדול. הצהרות מותנות מגיעות בכמה סוגים:

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

הצהרה אם

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

אם מצב:

    <входящее выражение 1>

    <входящее выражение 2>

<не входящее выражение>

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

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

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

לפי תיעוד השפה, ההזחה היא 4 רווחים. 

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

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

הנה קטע קוד לדוגמא לאופן הפעולה של האופרטור הזה.

number = int(input(“הזן מספר: “))

אם מספר > 10:

    print ("המספר גדול מ-10")

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

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

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

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

עכשיו בואו ננתח את רצף הפקודות הזה.

number = int(input(“כתוב מספר: “))

אם מספר > 10:

    print ("שורה ראשונה")

    print("שורה שנייה")

    print ("שורה שלישית")

print("השורה שמתבצעת, ללא קשר למספר שהוזן")

print ("סיום יישום")

נסה לנחש מה יהיה הפלט אם תזין את הערכים 2, 5, 10, 15, 50.

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

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

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

>>>

>>> n = 100

>>> אם n > 10:

...

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

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

>>>

>>> n = 100

>>> אם n > 10:

… print(«nv 10»)

...

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

אופרטור ביטוי אחרת

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

אם מצב:

    # אם לחסום

    הצהרה 1

    הצהרה 2

    וכן הלאה

else

    עוד בלוק אחד

    הצהרה 3

    הצהרה 4

    וכולי:

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

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

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

radius = int(input(“Enter radius: “))

אם רדיוס >= 0:

    print("היקף = ", 2 * 3.14 * רדיוס)

    print(“Area = “, 3.14 * רדיוס ** 2)

    else

        print("אנא הזן מספר חיובי")

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

בואו ניתן עוד מקרה שימוש (שבו הכל יהיה נכון עם יישור מפעיל) – רכיב אפליקציה שבודק סיסמה.

password = input ("הזן סיסמה: ")

אם סיסמה == «ששש»:

    print ("ברוך הבא")

else

    print ("הגישה נדחתה")

הוראה זו מדלגת על האדם הלאה אם ​​הסיסמה היא sshh. אם יש שילוב אחר של אותיות ומספרים, הוא מציג את ההודעה "הגישה נדחתה".

הצהרה-ביטוי אם-elif-else

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

if condition_1:

    # אם לחסום

    הצהרה

    הצהרה

    עוד הצהרה

elif condition_2:

    # בלוק אליף ראשון

    הצהרה

    הצהרה

    עוד הצהרה

elif condition_3:

    # בלוק אליף שני

    הצהרה

    הצהרה

    עוד הצהרה

...

אחר

    הצהרה

    הצהרה

    עוד הצהרה

אתה יכול לציין כל מספר של תנאים נוספים.

הצהרות מקוננות

דרך נוספת ליישם מספר תנאים היא הוספת בדיקות תנאים נוספות בבלוק if.

מַפעִיל if בתוך בלוק מצב אחר

gre_score = int(input(“הזן את מסגרת האשראי הנוכחית שלך”))

per_grad = int(input(“הזן את דירוג האשראי שלך: “))

אם per_grad > 70:

    # בלוק חיצוני אם

        אם gre_score > 150:

            # בלוק פנימי אם

    print("מזל טוב, קיבלת הלוואה")

else

    print ("מצטערים, אינך זכאי להלוואה")

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

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

עכשיו בואו נעבד קצת את התוכנית הזו.

gre_score = int(input(“הזן מגבלה נוכחית: “))

per_grad = int(input(“הזן ציון אשראי: “))

אם per_grad > 70:

    אם gre_score > 150:

        print("מזל טוב, קיבלת הלוואה")

    else

        הדפס ("מסגרת האשראי שלך נמוכה")

else

    print("מצטערים, אינך זכאי לזיכוי")

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

הצהרת if-else בתוך תנאי אחר

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

score = int(input(“הזן את הציון שלך: “))

אם ציון >= 90:

    print("נהדר! הציון שלך הוא א')

else

    אם ציון >= 80:

print("נהדר! הציון שלך הוא ב')

    else

אם ציון >= 70:

    print("טוב! הציון שלך הוא ג')

else

    אם ציון >= 60:

print(“הציון שלך הוא D. כדאי לחזור על החומר.”)

    else

print("נכשלת בבחינה")

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

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