מה זה משתנה?

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

איך משתנה עובד

שלושה דברים קורים למשתנה במהלך תוכנית:

1. יצירה. התוכנית שומרת זיכרון לערך ומצמידה אליו שם. ב-Python זה קורה בפעם הראשונה שמבצעים השמה לשם. ב-Java וב-C מצהירים קודם על המשתנה, עם טיפוס, כמו int score;.
2. השמה. ערך נשמר תחת השם עם =. השמה נוספת מחליפה את הערך הישן.
3. שימוש. בכל מקום שהשם מופיע בביטוי, התוכנית קוראת את הערך שהוא מחזיק באותו רגע.

score = 0
print("Start:", score)

score = score + 10
print("After one point:", score)

score = score * 2
print("Doubled:", score)

Start: 0
After one point: 10
Doubled: 20

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

סימן השוויון פירושו "שמור"

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

כדי לשאול אם שני ערכים שווים, שפות תכנות משתמשות באופרטור אחר, ==. הביטוי x == 5 לא משנה שום דבר, הוא מחזיר True או False, כלומר בוליאני.

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

משתנים וטיפוסי נתונים

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

ב-Python וב-JavaScript, הערך הוא שנושא את הטיפוס, ומשתנה אחד יכול להחזיק ערכים מטיפוסים שונים לאורך הזמן. זה נקרא טיפוסיות דינמית (dynamic typing):

value = 42
print(value, type(value))

value = "forty-two"
print(value, type(value))

42 <class 'int'>
forty-two <class 'str'>

ב-Java, C ו-C++, למשתנה יש טיפוס קבוע שנבחר כשמצהירים עליו. זו טיפוסיות סטטית (static typing): הקומפיילר דוחה קוד שמנסה לשמור טקסט במשתנה int, עוד לפני שהתוכנית רצה.

int age = 30;          // Java: type, name, value
String name = "Rosa";

let age = 30;          // JavaScript: can be reassigned
const PI = 3.14159;    // cannot be reassigned

ב-C, הטיפוס קובע גם כמה זיכרון המשתנה תופס. int הוא 4 בתים כמעט בכל מערכת עכשווית, double הוא 8, ו-char הוא בדיוק 1. כדי לשמור הרבה ערכים תחת שם אחד, למשל את כל התוצאות במשחק, משתמשים במערך או ברשימה ומגיעים לכל ערך לפי המיקום שלו, כמו scores[0].

קופסאות ותוויות

תמונה נפוצה של משתנה היא קופסה שמחזיקה ערך. התמונה הזו מתאימה היטב ל-C: int x; הוא באמת אזור קבוע בזיכרון, ו-y = x; מעתיק את הערך לאזור שני.

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

x = 5
y = x
y = y + 1
print(x, y)

a = [1, 2, 3]
b = a
b.append(4)
print(a)

5 6
[1, 2, 3, 4]

עם המספרים, y = y + 1 יוצר מספר חדש ומעביר אליו את התווית y, ולכן x עדיין מתייחס ל-5. עם הרשימה, b = a לא מעתיק שום דבר: שני השמות מתייחסים לרשימה אחת, ולכן שינוי שנעשה דרך b נראה גם דרך a. כתבו b = a.copy() כשאתם רוצים רשימה נפרדת. אובייקטים ומערכים ב-Java וב-JavaScript מתנהגים באותה צורה.

טווח הכרה (scope): איפה משתנה קיים

משתנה נראה רק בחלק מהתוכנית, שנקרא טווח ההכרה (scope) שלו. משתנה שנוצר בתוך פונקציה הוא מקומי: הוא קיים בזמן שהפונקציה רצה ונעלם כשהיא מחזירה ערך. משתנה שנוצר ברמה העליונה של קובץ הוא גלובלי, ואפשר לקרוא אותו בכל מקום בקובץ.

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

איך נותנים שמות למשתנים

שמות טובים אומרים מה המשמעות של הערך: total_price, is_logged_in, retries_left. לרוב השפות יש אותם כללים:

• שם מורכב מאותיות, ספרות וקווים תחתונים, ואסור שיתחיל בספרה;
• שם לא יכול להיות מילת מפתח של השפה, כמו if, for או class;
• יש הבחנה בין אותיות גדולות לקטנות, ולכן total ו-Total הם שני משתנים שונים.

הסגנון משתנה משפה לשפה. Python משתמש ב-snake_case (user_name), ואילו Java ו-JavaScript משתמשות ב-camelCase (userName). ערכים שאסור שישתנו מקבלים לעיתים קרובות שם באותיות גדולות, כמו MAX_SIZE.

טעויות נפוצות

שימוש במשתנה לפני שיש לו ערך. Python נעצר עם NameError:

price = 19.99
print(total)

NameError: name 'total' is not defined

אותה שגיאה מופיעה כששם כתוב עם שגיאת כתיב, כי totla ו-total הם שמות שונים מבחינת המחשב.

כתיבת = כשהתכוונתם ל-==. ב-Python, if x = 5: היא שגיאת תחביר, ולכן מגלים אותה מיד. ב-C וב-JavaScript, if (x = 5) הוא קוד תקין: הוא שומר 5 ב-x, והתנאי תמיד מתקיים. התוכנית רצה ונותנת תוצאות שגויות, שגיאה לוגית שיכול לקחת הרבה זמן למצוא.

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

לאן ממשיכים מכאן

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