לופּס זענען איינער פון די הויפּט מכשירים פון קיין שפּראַך. עס זענען צוויי יקערדיק לופּס אין פּיטהאָן, איינער פון וואָס איז בשעת. באַטראַכטן עס, און אויך פֿאַר אַ בעסער פארשטאנד פון די בילד, איינער מער. טאַקע, אין פאַרגלייַך מיט עפּעס ענלעך, עס איז פיל גרינגער צו פֿאַרשטיין קיין מאַטעריאַל, איז ניט עס?
דער באַגריף פון אַ ציקל
א שלייף איז דארף ווען אַ זיכער קאַמף דאַרף זיין דורכגעקאָכט עטלעכע מאָל. דאָס איז זייער סימפּלאַסטיק, ווייַל אין פאַקט די קייט פון אַפּלאַקיישאַנז פֿאַר סייקאַלז איז פיל מער. עס זענען צוויי הויפּט טייפּס פון לופּס אין פּיטהאָן: פֿאַר און בשעת. די מערסט פאָלקס איז פֿאַר.
אין אַדישאַן צו ספּעציפיש אַקשאַנז, איר קענען שלייף פאַרשידענע ברעקלעך פון קאָד אַרויף צו אַ זיכער פונט. דאָס קען זיין אַ זיכער נומער פון מאל, אָדער ווי לאַנג ווי אַ באַזונדער צושטאַנד איז אמת.
איידער מיר אָנהייבן צו פֿאַרשטיין די טייפּס פון לופּס און בשעת, אין באַזונדער, מיר נאָך דאַרפֿן צו פֿאַרשטיין וואָס יטעראַטיאָן איז. דאָס איז איין יבערכאַזערונג פון אַ קאַמף אָדער סיקוואַנס פון אַקשאַנז בעשאַס דעם קראַנט ציקל אין דעם קראַנט אַפּלאַקיישאַן לויפן.
ציקל פֿאַר
אונדזער For שלייף איז נישט אַ טאָמבאַנק, ווי אין פילע אנדערע שפּראַכן. זייַן אַרבעט איז צו ינומערייט אַ זיכער סיקוואַנס פון וואַלועס. וואס מיינט עס? זאל ס זאָגן מיר האָבן אַ רשימה פון עלעמענטן. ערשטער, די שלייף נעמט די ערשטער, רגע, דריט, און אַזוי אויף.
די מייַלע פון דעם שלייף אין פּיטהאָן איז אַז איר טאָן ניט דאַרפֿן צו באַשטימען דעם אינדעקס פון די עלעמענט צו וויסן ווען צו אַרויסגאַנג די שלייף. אַלץ וועט זיין געטאן אויטאָמאַטיש.
>>> ספּיסאָק = [10, 40, 20, 30]
>>> פֿאַר עלעמענט אין ספּיסאָק:
… דרוק (עלעמענט + 2)
...
12
42
22
32
אין אונדזער בייַשפּיל, מיר געוויינט די בייַטעוודיק עלעמענט נאָך דעם פֿאַר באַפֿעל. אין אַלגעמיין, דער נאָמען קען זיין עפּעס. פֿאַר בייַשפּיל, אַ פאָלקס באַצייכענונג איז י. און מיט יעדער יטעראַטיאָן, דעם בייַטעוודיק וועט זיין אַסיינד אַ ספּעציפיש כייפעץ פון דער רשימה, וואָס מיר גערופן די צונעמען וואָרט.
אין אונדזער פאַל, די רשימה איז אַ סיקוואַנס פון נומערן 10,40,20,30. אין יעדער יטעראַטיאָן, די קאָראַספּאַנדינג ווערט אויס אין די בייַטעוודיק. פֿאַר בייַשפּיל, ווי באַלד ווי די שלייף סטאַרץ, די בייַטעוודיק עלעמענט די ווערט 10 איז אַסיינד. אין דער ווייַטער יטעראַטיאָן, די צען ווערט אין די נומער 40, די דריט מאָל עס טורנס אין די נומער 20, און לעסאָף, אויף די לעצטע יטעראַטיאָן פון די שלייף, עס טורנס אין 30.
דער סיגנאַל פֿאַר די סוף פון די ציקל איז דער סוף פון די עלעמענטן אין דער רשימה.
אויב איר דאַרפֿן די שלייף צו דורכפירן אַ קלאַסיש ינומעריישאַן פון וואַלועס, ווי אין אנדערע פּראָגראַממינג שפּראַכן, איר זאָל מאַכן אַ רשימה מיט אַ סיקוואַנס פון נאַטירלעך נומערן אַרויף צו די ווערט מיר דאַרפֿן.
>>> ספּיסאָק = [1,2,3,4,5]
אָדער נוצן די פֿונקציע לן(), צו באַשטימען די לענג פון די רשימה. אבער אין דעם פאַל עס איז בעסער צו נוצן אַ שלייף בשעת, ווייַל עס איז ניט דאַרפֿן צו נוצן אַ בייַטעוודיק.
אויב איר דאַרפֿן צו טוישן די סיקוואַנס פון וואַלועס אין דער רשימה, שלייף פֿאַר און דאָ קומט צו דער הילף. צו טאָן דאָס, אין יעדער יטעראַטיאָן, יעדער עלעמענט פון דער רשימה מוזן זיין אַסיינד אַ צונעמען ווערט.
בשעת לופּ
ניט ענלעך דעם ציקל פֿאַר, וואָס פשוט יטערייץ איבער די וואַלועס פון די סיקוואַנס, די שלייף ווייַלע האט מער ניצט. דער נאָמען פון דעם טיפּ פון סייקאַלז איז איבערגעזעצט ווי "נאָך". דאָס הייסט, "ביז".
דאָס איז אַ וניווערסאַל שלייף וואָס איז געפֿונען אין אַלע פּראָגראַממינג שפּראַכן. און אין עטלעכע וועגן עס ריזעמבאַלז אַ קאַנדישאַנאַל אָפּעראַטאָר יו, וואָס פּערפאָרמז אַ טשעק צו זען אויב אַ זיכער צושטאַנד איז באגעגנט. בלויז אין קאַנטראַסט צו די קאַנדישאַנאַל אָפּעראַטאָר, ווייַלע פּערפאָרמז די טשעק אין יעדער יטעראַטיאָן, ניט נאָר אַמאָל. און בלויז אויב די צושטאַנד איז פאַלש, די שלייף ענדס און די באַפֿעל וואָס גייט עס איז עקסאַקיוטאַד. אין פּשוט ווערטער, אויב די סיטואַציע אין וואָס ער אַרבעט איז נישט גילטיק.
אויב מיר ציען אַ ציקל ווייַלע סימפּלי, דאָס איז געטאן מיט אַזאַ אַ סכעמע.
די הויפּט צווייַג פון די פּראָגראַם (וואָס לויפט אַרויס די שלייף) איז דיפּיקטיד אין דעם פיגור מיט בלוי רעקטאַנגגאַלז. טערקווויז רעפּראַזענץ די גוף פון די ציקל. אין קער, אַ רהאָמבוס איז אַ צושטאַנד וואָס איז אָפּגעשטעלט אין יעדער יטעראַטיאָן.
ציקל ווייַלע קענען פירן צו צוויי אויסנעמען:
- אויב אין די אָנהייב פון די שלייף די לאַדזשיקאַל אויסדרוק איז נישט אמת, עס פשוט טוט נישט אָנהייבן, נאָך געענדיקט איידער דורכפירונג. אין אַלגעמיין, דעם סיטואַציע איז נאָרמאַל, ווייַל אונטער זיכער צושטאנדן, די אַפּלאַקיישאַן קען נישט צושטעלן די בייַזייַן פון אויסדרוקן אין די שלייף גוף.
- אויב דער אויסדרוק איז שטענדיק אמת, דאָס קען פירן צו אַ שלייף. אַז איז, צו די סאָף סקראָללינג פון די ציקל. דעריבער, אין אַזאַ מגילה, עס זאָל שטענדיק זיין אַן אַרויסגאַנג ויסזאָגונג פון די שלייף אָדער פּראָגראַם. אָבער, דעם סיטואַציע וועט אויפשטיין אויב די פּראָגראַם איז ביכולת צו באַשליסן די אמת אָדער פאַלשקייט פון אַ באַזונדער צושטאַנד. אויב זי ניט אַנדערש צו טאָן דאָס, אַ טעות איז אומגעקערט מיט די טערמאַניישאַן פון די פּראָגראַם. אָדער איר קענען שעפּן דעם טעות, און אויב עס אַקערז, זיכער קאָד וועט זיין עקסאַקיוטאַד.
עס קענען זיין אַ ריזיק נומער פון אָפּציעס פֿאַר ווי צו שעפּן אַ טעות. פֿאַר בייַשפּיל, די פּראָגראַם קען פרעגן די באַניצער צו אַרייַן דאַטן ריכטיק. אַזוי, אויב אַ מענטש האָט אָנגעוויזן אַ נעגאַטיוו נומער ווו עס קען נאָר זיין positive, אָדער אריין אותיות ווו נאָר נומערן זאָל זיין, די פּראָגראַם קענען זאָגן וועגן אים.
בשעת שלייף ביישפילן
דאָ איז אַ בייַשפּיל פון קאָד וואָס כאַנדאַלז אַ טעות אין דעם פאַל.
n = אַרייַנשרייַב ("אַרייַן אַ גאַנץ נומער:")
בשעת טיפּ (n) != int:
Try:
n = ינט (n)
אַחוץ ValueError:
print ("פאַלש פּאָזיציע!")
n = אַרייַנשרייַב ("אַרייַן אַ גאַנץ נומער:")
אויב n % 2 == 0:
print ("אפילו")
אַנדערש:
print ("מאָדנע")
האַלטן אין מיינונג אַז Python ניצט קאָלאָנס צו דערקלערן קאָמפּלעקס קאָד קאַנסטראַקשאַנז.
אין דעם קאָד אויבן, מיר דיפיינד ווי אַ צושטאַנד אַז מיר זאָל קאָנטראָלירן אויב די נומער איז אַ גאַנץ נומער. אויב יאָ, פאַלש איז אומגעקערט. אויב נישט, דעמאָלט אמת.
אין די רגע טייל פון די קאָד, ווו דער אָפּעראַטאָר איז געניצט if, מיר געוויינט די % אָפּעראַטאָר צו געפֿינען די רעשט נאָך די אָפּטייל אָפּעראַציע. דער ווייַטער שריט איז צו קאָנטראָלירן אויב די נומער איז אפילו. אויב ניט, דעמאָלט דער רעשט איז איינער אין דעם פאַל. אַקקאָרדינגלי, די נומער איז מאָדנע.
אין פּשוט טערמינען, דער אויבן קאָד טשעק ערשטער אויב די שטריקל אריין דורך דער באַניצער איז אַ נומער. אויב יאָ, אַ צווייט טשעק איז געמאכט צו זען אויב עס איז אַ רעשט פון די אָפּטייל דורך צוויי. אבער די רגע בלאָק וועט נישט זיין עקסאַקיוטאַד ביז די ווערט אריין דורך די באַניצער איז נומעריק.
אַז איז, די שלייף וועט זיין קעסיידער עקסאַקיוטאַד ביז די צושטאַנד אַקערז. אין דעם סיטואַציע, עס אַרבעט ווי דאָס.
אַז איז, איר קענען גיין פון די פאַרקערט: שלייף אַ זיכער קאַמף ביז די געשעעניש ווערט פאַלש.
קאָד פּאַרסינג
איצט לאָמיר זען אין מער דעטאַל ווי דעם קאָד אַרבעט. צו טאָן דאָס, מיר וועלן אַנאַלייז עס שריט דורך שריט.
- ערשטער, דער באַניצער גייט אריין אַ שטריקל, וואָס איז אנגענומען דורך די בייַטעוודיק n.
- ניצן אַ שלייף ווייַלע דער טיפּ פון דעם בייַטעוודיק איז אָפּגעשטעלט. אויף דער ערשטער פּאָזיציע, עס איז נישט גלייַך ינט. דעריבער, ווי אַ רעזולטאַט פון די פּראָבע, עס איז געפונען אַז דעם צושטאַנד איז אמת. דעריבער, די שלייף גוף איז אריין.
- מיט דער הילף פון אַן אָפּעראַטאָר פּרובירן מיר פּרובירן צו קאָנווערט אַ שטריקל צו אַ נומער. אויב דאָס איז געטאן, קיין טעות אַקערז. אַקקאָרדינגלי, עס איז ניט דאַרפֿן צו פּראָצעס עס. דערפאר קערט זיך דער איבערזעצער צוריק צום אנהייב פון די שלייף, און לויט די רעזולטאטן פונעם טשעק קומט אויס אז עס איז געווארן א שלם. אַזוי לאָזן אונדז גיין צו שריט 7
- אויב די קאַנווערזשאַן איז ניט געראָטן, אַ ValueError איז ארלנגעווארפן. אין דעם פאַל, די פּראָגראַם לויפן איז געשיקט צו די אַחוץ האַנדלער.
- דער באַניצער גייט אריין אַ נייַע ווערט, וואָס איז אַסיינד צו די בייַטעוודיק n.
- דער יבערזעצער קערט צו שריט 2 און טשעק ווידער. אויב עס איז אַ ינטאַדזשער ווערט, גיין צו שריט 7. אויב נישט, די קאַנווערזשאַן איז פּרוווד ווידער לויט שריט 3.
- מיט דער הילף פון אַן אָפּעראַטאָר if באשלאסן אויב עס איז אַ רעשט נאָך דיוויידינג אַ נומער מיט 2.
- אויב ניט, דער טעקסט "אפילו" איז אומגעקערט.
- אויב ניט, דער טעקסט "מאָדנע" איז אומגעקערט.
באַטראַכטן איצט אַזאַ אַ בייַשפּיל. פּרוּווט צו באַשליסן ווי פילע מאָל דעם ציקל וועט דורכגיין?
גאַנץ = 100
איך = קסנומקס
בשעת איך <5:
n = int (אינפוט ())
גאַנץ = גאַנץ — נ
איך = איך + 1
print ("בלייבן", גאַנץ)
די ריכטיק ענטפֿערן איז 5. טכילעס, די ווערט פון די בייַטעוודיק i – נול. דער יבערזעצער טשעקס אויב די בייַטעוודיק איז גלייַך i 4 אָדער ווייניקער. אויב יאָ, די ווערט איז אומגעקערט. ריכטיק, און די שלייף איז עקסאַקיוטאַד אַקאָרדינגלי. די ווערט איז געוואקסן מיט איין.
נאָך דער ערשטער יטעראַטיאָן, די ווערט פון די בייַטעוודיק ווערט 1. אַ טשעק איז דורכגעקאָכט, און דער פּראָגראַם פארשטייט אַז די נומער איז ווידער ווייניקער ווי 5. אַקקאָרדינגלי, די שלייף גוף איז עקסאַקיוטאַד פֿאַר די צווייט מאָל. זינט די סטעפּס זענען ענלעך, די ווערט איז אויך געוואקסן מיט איין, און די בייַטעוודיק איז איצט גלייַך צו 2.
דעם ווערט איז אויך ווייניקער ווי פינף. דערנאָך די שלייף איז עקסאַקיוטאַד אַ דריט מאָל, צוגעגעבן צו די בייַטעוודיק i 1 און עס איז אַסיינד די ווערט 3. דאָס איז ווידער ווייניקער ווי פינף. און אַזוי עס קומט צו די זעקסט יטעראַטיאָן פון די שלייף, אין וואָס די ווערט פון די בייַטעוודיק i איז גלייַך 5 (נאָך אַלע, עס איז געווען ערידזשנאַלי נול, ווי ווייַט ווי מיר געדענקען). אַקקאָרדינגלי, דעם צושטאַנד טוט נישט פאָרן די פּראָבע, און די שלייף איז אויטאָמאַטיש טערמאַנייטיד און די יבערגאַנג צו דער ווייַטער שריט, וואָס איז אַרויס עס (אָדער פּראָגראַם טערמאַניישאַן, אויב די פאלגענדע סטעפּס זענען נישט צוגעשטעלט), איז דורכגעקאָכט.
דער ציקל קען אויך פאַלן אין די פאַרקערט ריכטונג. דאָ איז אַ בייַשפּיל פון קאָד ווו, מיט יעדער סאַבסאַקוואַנט יטעראַטיאָן, איינער איז סאַבטראַקטיד פון די קראַנט ווערט פון די בייַטעוודיק.
גאַנץ = 100
בשעת גאַנץ> 0:
n = int (אינפוט ())
גאַנץ = גאַנץ — נ
print ("מיטל ויסגעמאַטערט")
פּרוּווט צו טרעפן וואָס דעם פּראָגראַם טוט! ימאַדזשאַן אַז אין אַ בייַטעוודיק גאַנץ אינפֿאָרמאַציע וועגן די פּראָגראַם מיטל איז סטאָרד. יעדער מאָל דער יבערזעצער טשעקס אויב די מיטל יגזיסץ. אויב ניט, דער טעקסט "ריסאָרס ויסגעמאַטערט" איז געוויזן און די פּראָגראַם קלאָוזיז. און מיט יעדער יטעראַטיאָן פון די שלייף, די מיטל דיקריסאַז מיט די נומער וואָס דער באַניצער ספּעציפיצירט.
און איצט לעקציעס. פּרוּווט טשאַנגינג די אויבן קאָד אַזוי אַז די בייַטעוודיק קען נישט פיזיקלי ווערן נעגאַטיוו.
דער קאָד איז גוט
иси
העלא
לאָל