מדריך | מבוא לתכנות בפייתון - פרק ב'

[מאן דאמר 5]

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

משתנה

משתנה הוא בעצם אזור מוגדר בזיכרון המחשב המכיל נתון בודד או מאגר נתונים, עם כינוי ייחודי. הסיבה שהוא נקרא 'משתנה' היא שיש לו גם אח מקביל - ה'קבוע', אודותיו נרחיב בהמשך אי"ה.
כדי לשמור נתון כל שהוא בזיכרון המחשב באופן שנוכל אחר כך להשתמש בו אנחנו חייבים לתת לו כינוי ייחודי, כך שנוכל אחר כך למצוא אותו לפי הכינוי. לדוגמא - נניח לצורך העניין שאני מלמד בתלמוד תורה, וכתבתי למחשב שיש לי 30 תלמידים בכיתה. כעת נוספו לי עוד שני ילדים, איך אני מעדכן בזיכרון המחשב את מספר התלמידים? הדרך תהיה פשוטה ביותר אם בתחילה שמרתי את מספר הילדים תחת הכינוי "מספר התלמידים", במקרה כזה מספיק שאכתוב עכשיו "הוסף 2 ל 'מספר התלמידים'", והמחשב כבר ימצא בזיכרון את הערך שאליו הצמדנו את הכינוי 'מספר התלמידים' ויעדכן אותו.
מסיבה זו לא יכולים להיות שני משתנים בעלי אותו שם. אם נכתוב פעם אחת: מספר התלמידים = 1, ואחר כך נכתוב: מספר התלמידים = 2 המחשב לא יצור משתנה חדש אלא יעדכן את ערך המשתנה מ1 ל 2.
איך זה נראה בפועל - איך מגדירים משתנה בפייתון? פשוט ביותר. כותבים שם משתנה, רווח, הסימן '=', שוב רווח, ואז את הערך של המשתנה, שהוא הנתון שאותו אנחנו שומרים כעת בזיכרון.
לדוגמא:
א = 1
ב = 2
ג = 3
ד = 4
כעת אפשר לכתוב א + ב, ופייתון יתייחס לזה כ 1 + 2, כי אלה הם הערכים המוגדרים במשתנים אלו. כמובן שאי אפשר לפנות למשתנה שאינו קיים, לדוגמא אם נכתוב א + ה נקבל הודעת שגיאה.
שם משתנה חייב להתחיל באות אנגלית קטנה או גדולה, ויכול להכיל גם מספרים וקו תחתון. אין אפשרות להשתמש ברווח בין מילים, במקום זאת נהוג להשתמש בקו תחתון, לדוגמא - מספר_התלמידים. כאן המקום להדגיש שבפייתון יש הבדל בין אותיות קטנות לגדולות, כך שאם נגדיר משתנה בשם A ונבקש אחר כך את a - פייתון לא יזהה אותו, ויכתוב לנו ש a לא קיים. חשוב לזכור זאת.
עד עכשיו ראינו משתנים שמכילים מספרים כערכים, אך ישנם עוד כמה סוגי טיפוסים של משתנים.
משתנה מסוג מחרוזת - משתנה שהערך שלו הוא אותיות או מילים. במקרה כזה יש להקיף את הערך במרכאות, כך:
א = "משה"
ניתן גם להשתמש במרכאות בודדות, מה שחשוב שלפני ואחרי המילה נשתמש באותו סימן, כמו 'משה' או "משה" ולא 'משה".
מה יקרה אם נקיף מספרים במרכאות, כמו - "1234"? זה תקין ולא תתקבל שגיאה, אבל לא יהיה למספר ערך מספרי אלא הוא ייחשב כמחרוזת, כך שלא נוכל לעשות עליו פעולות חשבוניות, לדוגמא אם נרצה לעשות "1" + 2 נקבל שגיאה.
חשוב לציין שאפשר גם לכתוב מילים בעברית בתור מחרוזת.
טיפוס נוסף הוא שבר עשרוני - בדיוק כמו מספר אבל עם נקודה עשרונית. נכתב כך:
א = 1.0
עוד טיפוס הוא משתנה בוליאני, שמכיל אמת או שקר. True - אמת, False - שקר. שימו לב שהאות הראשונה גדולה, אחרת כאמור פייתון לא יזהה את המילה.
משתנה בוליאני משמש כעין מתג בעל שני מצבים, לדוגמא אם נניח שיש לי בכיתה (אני מלמד, זוכרים?) ילד בשם דוד עם משקפיים אני אכתוב:
לדוד_יש_משקפיים = True (אמת)
ואז אם יום אחד אני ארצה להיזכר אם יש לדוד משקפיים או לא - פשוט אבקש מהמחשב לשלוף את הנתון הזה -"לדוד_יש_משקפיים", ואראה שזה אמת, אכן יש לו משקפיים. בקוד אמיתי יש שימוש רב למשתנים בוליאנים, כפי שבעז"ה נראה בהמשך.

פעולות על משתנים - יש מגוון רחב של פעולות שימושיות שאפשר לעשות עם משתנים על ידי שימוש בפונקציות, ועוד נגיע גם לזה אי"ה. כעת נראה רק את הפעולות הבסיסיות שאפשר לבצע:
במשתנה מסוג מספר אפשר לעשות כל פעולה חשבונית: + (חיבור), - (חיסור), * (כפל), / (חילוק) או // (חילוק ללא מספר עשרוני, כלומר נותן מספר שלם בלי נקודה עשרונית), ** (חזקה), % (מודולו).
אם יש לנו משתנה שמכיל מספר, לדוגמא -
א = 1
יהיה חוקי גם לכתוב א + א, וגם א + 2.
אותו דבר גם במשתנה מסוג שבר עשרוני.
במשתנה מסוג מחרוזת אפשר להשתמש ב + (חיבור), ולקבל חיבור של שתי המילים או האותיות. לדוגמא:
א = "משה"
ב = "דוד"
א + ב
"משהדוד"
משתנה בוליאני הוא כמו מספר, כשאמת (True) זה 1, ושקר (False) זה 0. לדוגמא:
א = True
ב = True
א + ב
2

נסו את זה!
(רק אל תשכחו לכתוב באנגלית...:)

תנאי

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

students = 30
if students == 30:
    students += 1
    print(students)

מה עשינו כאן? ראשית הגדרנו משתנה בשם students (תלמידים) שהערך שלו הוא 30.
לאחר מכן כתבנו תנאי - אם הערך של תלמידים שווה 30, ולסיום שורת התנאי מוסיפים נקודתיים :
ואז כתבנו את הפעולות שיתבצעו במידה והתנאי מתקיים - הוסף 1 למשתנה students , והדפס למסך את הערך המעודכן של students.
כפי ששמתם לב, הסימן == (פעמיים '=') בודק אם יש שוויון בין שני ערכים. ובמקרה שלנו אכן יש שוויון, כי הערך של students הוא אכן 30.
הסימן += לאחר שם המשתנה גורם להוסיף לערך הקיים את המספר הרצוי, במקרה שלנו 1.
רק להזכיר - אם היינו רושמים כך:
students = 1
הערך של students היה הופך ל 1 ולא ל 31 כמו שרצינו, לכן צריך לכתוב כך:
students += 1
כנ"ל אם נרצה להפחית מהערך הנוכחי נכתוב כך:
students -= 1

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

if students == 30:
    students += 1
print(students)

השורה השלישית תתבצע בין אם התנאי יתקיים ובין אם לא, משום שיצאנו מה'בלוק' של התנאי.

מומלץ לנסות גם את זה לפני שממשיכים הלאה...

לולאה

זוהי דרך נוחה מאוד לבצע פעולה מסוימת פעמים רבות בלי לכתוב אותה שוב ושוב.
ישנם שני סוגים של לולאות בפייתון האחת נקראת while (בזמן ש-), והשניה for (עבור).
הלולאה נקראת כך משום שהיא גורמת לפייתון לחזור שוב ושוב על אותה פקודה או סדרת פקודות, עד שהיא מסתיימת.
ניתן דוגמא תחביר של לולאת while:
"כל זמן שמספר התלמידים שווה ל 30 הוסף למספר התלמידים 1".
ובקוד אמיתי:

students = 30
while students == 30:
    students += 1

(גם כאן כמו שראינו בתנאי - חייבים להוסיף טאב בתחילת השורה שתתבצע בלולאה.)
נסביר מה כתבנו:
ראשית את המילה while, ולאחריה תנאי שכל זמן שהוא מתקיים הלולאה ממשיכה לרוץ. במקרה שלנו - כל זמן שהערך של students הוא 30.
בשורה שלאחר מכן כתבנו פקודה שתתבצע, והיא - להוסיף 1 ל students.
חשבו - כמה פעמים תתבצע הפקודה?
תשובה - פעם אחת בלבד. מדוע? כי בתחילה פייתון רואה את התנאי שכתבנו, ובודק האם students שווה 30. הוא רואה שאכן כך, ולכן ממשיך לשורה הבאה שמורה לו להוסיף 1 ל students. כעת פייתון חוזר שוב לתחילת הלולאה ובודק שוב האם התנאי מתקיים, אך כעת הערך של students הוא כבר 31, כלומר התנאי לא התקיים. בכך תסתיים ריצת הלולאה והתוכנית תגיע לסיומה.
כעת נכתוב לולאה שתרוץ כמה וכמה פעמים, ונכיר את הסימן '>' שמשמעותו 'קטן מ', ובאותה מידה '<' שווה 'גדול מ'.

students = 0
while students < 30:
    students += 1
    print(students)

מה יקרה עכשיו? התנאי שאנחנו בודקים בתחילה הוא האם ערכו של המשתנה students קטן מ 30, ואם כן - אנחנו מוסיפים לו 1. אם כן הלולאה תרוץ 30 פעמים עד ש students יהיה שווה 30 והתנאי יפסיק להתקיים, ואז הריצה תיגמר.
זהירות! היזהרו מלולאות כאלו - הם יכולות להיות אין סופיות. אם נכתוב תנאי שתמיד מתקיים - לדוגמא:

students = 2
while students > 1:
    students += 1

היות שהערך של students הוא 2, והתנאי הוא האם students גדול מ 1 - הלולאה תרוץ שוב ושוב ושוב ושוב ושוב ולעולם לא תפסיק, עד שהמחשב יקרוס. לכן שימו לב לכך, ואם בטעות קרה והפעלתם לולאה אין סופית - אם אתם מריצים את הקוד משורת הפקודה או מ idle לחיצה על ctrl + c תגרום לעצירת הריצה, ואם אתם עובדים עם סביבת עבודה כל שהיא כגון pycharm לחצו על סמל העצירה - לחצן עם ריבוע אדום קטן.

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

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

[מאן דאמר 5]

@מאן-דאמר-5 מצו"ב תרגיל למתחילים בפייתון, מי שקרא את המדריך הזה יידע לפתור אותו....

הדפיסו למסך סדרת מספרים מ 0 ל 100 בדלוגים כדלהלן: 0, 1, 3, 6 וכו'. כלומר כל פעם להוסיף למספר הקודם מספר הגדול ב 1 מהמספר הקודם שהוספנו. דהיינו - 0 + 0 = 0, 0 + 1 = 1, 1 + 2 = 3, 3 + 3 = 6, 6 + 4 = 10, וכן הלאה עד 100.
ההדפסה למסך היא באמצעות הפונקציה ()print, כאשר לתוך הסוגרים אפשר להכניס ערך כל שהוא, או משתנה, או תרגיל.
פתרון יפה יהיה באורך 6 שורות.