ינהאַלט
אין דעם פּראָצעס פון לערנען צו פּראָגראַם, עס איז אָפט נייטיק צו שאַפֿן מגילה וואָס זענען נישט אַזוי גרינג צו צולייגן אין פאַקטיש לעבן. נאָך אַלע, פון צייַט צו צייַט איר האָבן צו נאָכפאָלגן ינסטראַקשאַנז בלויז אונטער זיכער טנאָים. צו קענען צו ינסטרומענט דעם אין דעם פּראָגראַם, אַלע שפּראַכן האָבן קאָנטראָל סטייטמאַנץ. מיט זייער הילף, איר קענען קאָנטראָלירן די לויפן פון קאָד דורכפירונג, קריייטינג לופּס אָדער דורכפירן זיכער אַקשאַנז בלויז ווען אַ זיכער צושטאַנד איז אמת.
הייַנט מיר וועלן רעדן וועגן די אויב ויסזאָגונג, וואָס טשעקס די קראַנט סיטואַציע פֿאַר אַ זיכער צושטאַנד, און באזירט אויף דעם אינפֿאָרמאַציע, מאכט דיסיזשאַנז וועגן ווייַטער אַקשאַנז.
טייפּס פון קאָנטראָל סטייטמאַנץ
אין אַלגעמיין, אויב איז נישט דער בלויז ויסזאָגונג וואָס קאָנטראָלס די לויפן פון אַ פּראָגראַם. ווי געזונט ווי ער זיך קענען זיין אַ קאָמפּאָנענט פון אַ גרעסערע קייט פון אָפּערייטערז.
עס זענען אויך לופּס און סטייטמאַנץ וואָס קאָנטראָלירן דעם פּראָצעס פון זייַן דורכפירונג. הייַנט מיר וועלן נאָר רעדן וועגן די קאַנדישאַנאַל אָפּעראַטאָר און די קייטן אין וואָס עס קענען אָנטייל נעמען.
אין פּראָגראַממינג, עס איז אַזאַ אַ זאַך ווי בראַנטשינג. עס איז פּונקט דאָס וואָס מיטל אַ סיקוואַנס פון קאַמאַנדז וואָס איז עקסאַקיוטאַד בלויז אויב אַ זיכער צושטאַנד איז אמת. די קרייטיריאַ זיך קען זיין אַנדערש:
- יקוואַלאַטי פון אַ בייַטעוודיק צו אַ זיכער ווערט.
- פּערפאָרמינג אַ ספּעציפיש קאַמף.
- אַפּלאַקיישאַן שטאַט (קאַלאַפּסט אָדער נישט).
די ספּעקטרום קענען זיין פיל גרעסערע. קאַנדישאַנאַל סטייטמאַנץ קומען אין עטלעכע טייפּס:
- מיט איין צווייַג. אַז איז, אַ איין טשעק איז דורכגעקאָכט, ווי אַ רעזולטאַט פון וואָס זיכער אַקשאַנז זענען דורכגעקאָכט.
- מיט צוויי אָדער מער צווייגן. אויב קריטעריאָן 1 איז אמת, טשעק קריטעריאָן 2. אויב עס איז אמת, טשעק 3. און אַזוי, דורכפירן ווי פילע טשעקס ווי פארלאנגט.
- מיט עטלעכע באדינגונגען. אַלץ איז פּשוט דאָ. דער יבערזעצער טשעק פֿאַר קייפל טנאָים אָדער איינער פון זיי.
אויב ויסזאָגונג
די סטרוקטור פון די אויב סטאַטעמענט איז ענלעך אין אַלע שפּראַכן. אָבער, אין פּיטהאָן, זיין סינטאַקס איז עפּעס אַנדערש פון אַלע די אנדערע:
אויב צושטאַנד:
<входящее выражение 1>
<входящее выражение 2>
<не входящее выражение>
ערשטער, דער אָפּעראַטאָר זיך איז דערקלערט, נאָך וואָס די צושטאַנד אונטער וואָס עס סטאַרץ ארבעטן איז געשריבן. דער צושטאַנד קען זיין אמת אָדער פאַלש.
דעם איז נאכגעגאנגען דורך אַ בלאָק מיט קאַמאַנדז. אויב עס מיד גייט אַ קריטעריאָן צו זיין באגעגנט, די קאָראַספּאַנדינג סיקוואַנס פון קאַמאַנדז איז גערופֿן אויב בלאָק. איר קענען נוצן קיין נומער פון קאַמאַנדז אין עס.
ופמערקזאַמקייַט! די ינדענטיישאַן אין אַלע אויב בלאָק קאַמאַנדז מוזן זיין די זעלבע גרייס. די בלאָק באַונדריז זענען באשלאסן דורך די ינדענץ.
לויט די שפּראַך דאַקיומענטיישאַן, די ינדענטיישאַן איז 4 ספּייסאַז.
ווי אַזוי אַרבעט דעם אָפּעראַטאָר? ווען דער יבערזעצער זעט די אויב וואָרט, עס גלייך טשעק די אויסדרוק קעגן די באַניצער-ספּעסיפיעד קרייטיריאַ. אויב דאָס איז דער פאַל, ער סטאַרץ צו קוקן פֿאַר ינסטראַקשאַנז און נאָכגיין זיי. אַנדערש, אַלע קאַמאַנדז פון דעם בלאָק זענען סקיפּט.
אויב אַ דערקלערונג נאָך די צושטאַנד איז נישט ינדענטיד, עס איז נישט באהאנדלט ווי אַ אויב בלאָק. אין אונדזער סיטואַציע, דעם שורה איז
דאָ איז אַ קאָד סניפּאַט פֿאַר אַ בייַשפּיל פון ווי דער אָפּעראַטאָר אַרבעט.
נומער = int (אַרייַן אַ נומער: "))
אויב נומער> 10:
print ("די נומער איז גרעסער ווי 10")
דער פּראָגראַם פּראַמפּס דער באַניצער פֿאַר אַ נומער און טשעקס אויב עס איז גרעסער ווי 10. אויב אַזוי, עס קערט די צונעמען אינפֿאָרמאַציע. פֿאַר בייַשפּיל, אויב דער באַניצער גייט אריין די נומער 5, דער פּראָגראַם וועט פשוט ענדיקן, און דאָס איז עס.
אבער אויב איר ספּעציפיצירן די נומער 100, דער יבערזעצער וועט פֿאַרשטיין אַז עס איז מער ווי צען, און באַריכט עס.
ופמערקזאַמקייַט! אין אונדזער פאַל, אויב די צושטאַנד איז פאַלש, די פּראָגראַם סטאַפּס, ווייַל קיין קאַמאַנדז זענען נישט געגעבן נאָך די לימעד.
עס איז בלויז איין באַפֿעל אין די אויבן קאָד. אבער עס זענען פילע מער פון זיי. דער בלויז פאָדערונג איז צו ינדענט.
איצט לאָזן ס פונאַנדערקלייַבן דעם סיקוואַנס פון קאַמאַנדז.
נומער = int(ינפּוט ("שרייַבן אַ נומער:"))
אויב נומער> 10:
print ("ערשטער שורה")
דרוק ("צווייט שורה")
print ("דריט שורה")
print ("די שורה וואָס איז עקסאַקיוטאַד, ראַגאַרדלאַס פון די נומער אריין")
print ("סוף אַפּלאַקיישאַן")
פּרוּווט צו טרעפן וואָס די רעזולטאַט וועט זיין אויב איר אַרייַן די וואַלועס 2, 5, 10, 15, 50.
ווי איר קענען זען, אויב די נומער אריין דורך די באַניצער איז מער ווי צען, דריי שורות זענען רעזולטאַט + איינער מיט די טעקסט "לויפן יעדער מאָל ..." און איינער "סוף", און אויב ווייניקער ווי צען, בלויז איין, מיט אַ אַנדערש טעקסט. בלויז שורות 3,4,5 וועט זיין עקסאַקיוטאַד אויב אמת. אָבער, די לעצטע צוויי שורות וועט זיין געשריבן קיין ענין וואָס נומער דער באַניצער ספּעציפיצירט.
אויב איר נוצן די סטייטמאַנץ גלייַך אין די קאַנסאָול, דער רעזולטאַט וועט זיין אַנדערש. דער יבערזעצער מיד טורנס אויף די מולטי-שורה מאָדע אויב, נאָך ספּעציפיצירן די וועראַפאַקיישאַן קריטעריאָן, דריקן אַרייַן.
רעכן מיר האָבן געשריבן די פאלגענדע סיקוואַנס פון קאַמאַנדז.
>>>
>>> n = 100
>>> אויב n> 10:
...
נאָך דעם, מיר וועלן זען אַז >>> איז ריפּלייסט דורך עליפּסיס. דעם מיטל אַז די מולטילינע אַרייַנשרייַב מאָדע איז ענייבאַלד. אין פּשוט ווערטער, אויב איר דריקן אַרייַן, איר וועט זיין טראַנספערד צו די אַרייַנשרייַב פון די רגע בינע פון די לימעד.
און אין סדר צו אַרויסגאַנג דעם בלאָק, איר דאַרפֿן צו לייגן נאָך איין קאַנסטראַקשאַן צו דעם בלאָק if.
>>>
>>> n = 100
>>> אויב n> 10:
… print(«nv 10»)
...
אויב די צושטאַנד איז נישט אמת, די פּראָגראַם ענדס. דאָס איז אַ פּראָבלעם, ווייַל דער באַניצער קען זען אַזאַ אַ פּראָגראַם ווי פֿאַרמאַכט רעכט צו אַ דורכפאַל. דעריבער, עס איז נייטיק צו געבן באַמערקונגען צו דער באַניצער. פֿאַר דעם, אַ לינק איז געניצט אויב-אַנדערש.
אויסדרוק אָפּעראַטאָר אויב-אַנדערש
דער אָפּעראַטאָר אַלאַוז איר צו ינסטרומענט אַ לינק: אויב דער אויסדרוק גלייַכן אַ זיכער הערשן, דורכפירן די אַקשאַנז, און אויב נישט, אנדערע. אַז איז, עס אַלאַוז איר צו טיילן די לויפן פון די פּראָגראַם אין צוויי ראָודז. די סינטאַקס איז ינטואַטיוו:
אויב צושטאַנד:
# אויב בלאָק
דערקלערונג 1
דערקלערונג 2
און אַזוי אויף
אַנדערש:
# אנדער בלאק
דערקלערונג 3
דערקלערונג 4
און אזוי ווייטער:
זאל ס דערקלערן ווי דעם אָפּעראַטאָר אַרבעט. ערשטער, דער נאָרמאַל ויסזאָגונג איז עקסאַקיוטאַד אין די פאָדעם יו, טשעק צי עס שוועבעלעך צושטאַנד "אמת אָדער פאַלש". ווייַטער אַקשאַנז אָפענגען אויף די רעזולטאַטן פון די טשעק. אויב אמת, די לימעד וואָס איז אין די סיקוואַנס פון ינסטראַקשאַנז נאָך די צושטאַנד איז עקסאַקיוטאַד גלייַך. יו, אויב עס איז פאַלש, דעמאָלט אַנדערש.
דעם וועג איר קענען שעפּן ערראָרס. למשל, דער באַניצער דאַרף אַרייַן אַ ראַדיוס. דאָך, עס קען נאָר זיין אַ נומער מיט אַ פּלוס צייכן, אָדער עס איז אַ נאַל ווערט. אויב עס איז ווייניקער ווי 0, איר דאַרפֿן צו געבן אַ אָנזאָג צו אַרייַן אַ positive נומער.
דאָ איז דער קאָד וואָס ימפּלאַמאַנץ דעם אַרבעט. אבער עס איז איין טעות דאָ. פּרוּווט צו טרעפן וואָס איינער.
ראַדיוס = int(אַרייַן ראַדיוס: "))
אויב ראַדיוס >= 0:
print ("סירקומפערענסע = ", 2 * 3.14 * ראַדיוס)
print ("שטח = ", 3.14 * ראַדיוס ** 2)
אַנדערש:
print ("ביטע אַרייַן אַ positive נומער")
אינדענטאַטיאָן מיסמאַטש טעות. אויב און אַנדערש מוזן זיין ליגן אָן זיי אָדער מיט די זעלבע נומער פון זיי (דיפּענדינג אויף צי זיי זענען נעסטעד אָדער נישט).
לאָמיר געבן אן אנדער נוצן פאַל (ווו אַלץ וועט זיין ריכטיק מיט אָפּעראַטאָר אַליינמאַנט) - אַ אַפּלאַקיישאַן עלעמענט וואָס טשעקס אַ פּאַראָל.
פּאַראָל = אַרייַנשרייַב ("אַרייַן פּאַראָל:")
אויב פּאַראָל == «שש»:
print ("באַגריסונג")
אַנדערש:
print ("אַקסעס געלייקנט")
די ינסטרוקטיאָן סקיפּס דעם מענטש ווייַטער אויב די פּאַראָל איז sshh. אויב קיין אנדערע קאָמבינאַציע פון אותיות און נומערן, עס דיספּלייז די אָנזאָג "אַקסעס געלייקנט".
דערקלערונג-אויסדרוק אויב-עליף-אַנדערש
בלויז אויב עטלעכע באדינגונגען זענען נישט אמת, די ויסזאָגונג וואָס איז אין די בלאָק איז עקסאַקיוטאַד. אַנדערש. דער אויסדרוק אַרבעט ווי דאָס.
אויב צושטאַנד_1:
# אויב בלאָק
ויסזאָגונג
ויסזאָגונג
מער דערקלערונג
עליף צושטאַנד_2:
# ערשטער עליף בלאָק
ויסזאָגונג
ויסזאָגונג
מער דערקלערונג
עליף צושטאַנד_3:
# צווייטער עליף בלאק
ויסזאָגונג
ויסזאָגונג
מער דערקלערונג
...
אַנדערש
ויסזאָגונג
ויסזאָגונג
מער דערקלערונג
איר קענען ספּעציפיצירן קיין נומער פון נאָך באדינגונגען.
נעסטעד סטייטמאַנץ
אן אנדער וועג צו ינסטרומענט קייפל טנאָים איז צו אַרייַנלייגן נאָך צושטאַנד טשעקס אין די אויב בלאָק.
אָפּעראַטאָר if ין אן אנדער צושטאַנד בלאָק
gre_score = int(ינפּוט ("אַרייַן דיין קראַנט קרעדיט שיעור"))
per_grad = int(input ("אַרייַן דיין קרעדיט שאַץ:"))
אויב פּער_גראַד> 70:
# ויסווייניקסט אויב בלאָק
אויב gre_score> 150:
# ינער אויב בלאָק
print ("מאַזל - טאָוו, איר האָט באקומען אַ אַנטלייַען")
אַנדערש:
print ("אנטשולדיגט, איר זענט נישט בארעכטיגט פֿאַר אַ אַנטלייַען")
דער פּראָגראַם פּערפאָרמז אַ קרעדיט שאַץ טשעק. אויב עס איז ווייניקער ווי 70, די פּראָגראַם ריפּאָרץ אַז דער באַניצער איז נישט בארעכטיגט פֿאַר קרעדיט. אויב עס איז גרעסער, אַ צווייט טשעק איז דורכגעקאָכט צו זען אויב די קראַנט קרעדיט שיעור איז גרעסער ווי 150. אויב יאָ, דעמאָלט אַ אָנזאָג איז געוויזן אַז די אַנטלייַען איז ארויס.
אויב ביידע וואַלועס זענען פאַלש, אַ אָנזאָג איז געוויזן אַז דער באַניצער האט נישט די מעגלעכקייט צו באַקומען אַ אַנטלייַען.
איצט לאָזן אונדז ריווערק דעם פּראָגראַם אַ ביסל.
gre_score = int (אַרייַן קראַנט שיעור: "))
per_grad = int(אַרייַן קרעדיט כעזשבן: "))
אויב פּער_גראַד> 70:
אויב gre_score> 150:
print ("מאַזל - טאָוו, איר האָט באקומען אַ אַנטלייַען")
אַנדערש:
print ("דיין קרעדיט לימיט איז נידעריק")
אַנדערש:
print ("אנטשולדיגט, איר זענט נישט בארעכטיגט פֿאַר קרעדיט")
דער קאָד זיך איז זייער ענלעך, אָבער נעסטעד if אויך גיט אַן אַלגערידאַם אין פאַל די צושטאַנד פון עס טורנס אויס צו זיין פאַלש. אַז איז, די שיעור אויף די קאָרט איז ניט גענוגיק, אָבער די קרעדיט געשיכטע איז גוט, דער אָנזאָג "איר האָבן אַ נידעריק קרעדיט שאַץ" איז געוויזן.
אויב-אנדערע דערקלערונג אין אַ צושטאַנד אַנדערש
לאָמיר מאַכן אן אנדער פּראָגראַם וואָס דיטערמאַנז אַ תּלמיד ס מיינונג באזירט אויף פּרובירן סקאָרז.
כעזשבן = int(ינפּוט ("אַרייַן דיין כעזשבן:"))
אויב כעזשבן >= 90:
print("גרויס! דיין מיינונג איז א")
אַנדערש:
אויב כעזשבן >= 80:
print("גרויס! דיין מיינונג איז ב")
אַנדערש:
אויב כעזשבן >= 70:
print ("גוט! דיין מיינונג איז C")
אַנדערש:
אויב כעזשבן >= 60:
print ("דיין מיינונג איז ד. עס איז ווערט איבערחזרן דעם מאַטעריאַל.")
אַנדערש:
print ("איר דורכפאַלן די עקסאַם")
די אַפּלאַקיישאַן ערשטער טשעקס צו זען אויב די כעזשבן איז גרעסער ווי אָדער גלייַך צו 90. אויב יאָ, עס קערט אַן א מיינונג. אויב דעם צושטאַנד איז פאַלש, סאַבסאַקוואַנט טשעקס זענען דורכגעקאָכט. מיר זען אַז דער אַלגערידאַם איז כּמעט די זעלבע בייַ ערשטער בליק. אַזוי אַנשטאָט פון טשעק ין אַנדערש בעסער צו נוצן אַ קאָמבינאַציע אויב-עליף-אַנדערש.
אַזוי דער אָפּעראַטאָר if פּערפאָרמז אַ זייער וויכטיק פֿונקציע - עס מאכט זיכער אַז זיכער ברעקלעך פון קאָד זענען עקסאַקיוטאַד בלויז אויב עס איז אַ נויט פֿאַר עס. עס איז אוממעגלעך צו ימאַדזשאַן פּראָגראַממינג אָן עס, ווייַל אפילו די סימפּלאַסט אַלגערידאַמז דאַרפן פאָרקס ווי "אויב איר גיין צו די לינקס, איר וועט געפֿינען עס, און אויב איר גיין צו די רעכט, איר דאַרפֿן צו טאָן דאָס און אַז."