א.3 — פקודות בסיסיות

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

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

בפרק הקודם הרצנו תוכנית של שורה אחת שרק מדפיסה טקסט. בפרק הזה נוסיף לה את אבני הבניין שכל תוכנית צריכה: משתנה (Variable) — שם שנותנים לערך כדי שנוכל לשמור אותו ולהשתמש בו שוב; טיפוס (Type) — סוג הערך, למשל מספר שלם או טקסט, שקובע אילו פעולות אפשר לעשות איתו; ופקודות הקלט והפלט input ו־print, שדרכן התוכנית מקבלת מידע מהמשתמש ומציגה לו תוצאות. נתחיל במשתנים ובטיפוסים, נמשיך לפעולות חשבון ולקלט ופלט, ונסיים בכמה דרכים לשלוט בצורת ההדפסה.

פתיחת המחברת ב־Colab · השיעור וההרצאה באתר הקורס

מחברות האוניברסיטה הפתוחה — 1-יסודות השפה

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

כדי לשמור ערך במשתנה מבצעים השמה (Assignment). בהשמה קושרים שם לערך: כותבים את שם המשתנה, = ואת הערך. אין צורך בהצהרת טיפוס — הטיפוס נקבע לפי הערך.

בדוגמה הבאה מופיעים ארבעת הטיפוסים הבסיסיים שנשתמש בהם: int — מספר שלם, float — מספר עשרוני, str — מחרוזת של תווים (טקסט בין מירכאות), ו־bool — ערך אמת או שקר. הפונקציה type מחזירה את הטיפוס של ערך, וכך אפשר לבדוק מה פייתון קבעה.

score = 10          # int
speed = 2.5         # float
player = "Dana"     # str
game_over = False  # bool

print(type(score))

פלט

<class 'int'>

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

value = 5
value = "five"
print(type(value))

פלט

<class 'str'>

משתנה בוליאני — bool

משתנה בוליאני שומר אחד משני ערכים: True (אמת) או False (שקר). הוא מתאים לשמירת תשובה לשאלה של כן או לא. למשל, המשתנה game_over מתאר האם המשחק הסתיים: False אומר שלא, ו־True אומר שכן.

בפייתון כותבים True ו־False באות ראשונה גדולה וללא מירכאות. הכתיבה "True" היא מחרוזת, ולא ערך בוליאני.

game_over = False
print("Game over:", game_over)
print("Type:", type(game_over))

game_over = True
print("Game over:", game_over)

פלט

Game over: False
Type: <class 'bool'>
Game over: True

השוואה מחזירה ערך בוליאני

אפשר לקבל ערך בוליאני גם כתוצאה מהשוואה. למשל, score == 10 שואלת האם הניקוד שווה ל־10, ומחזירה True אם כן ו־False אם לא.

חשוב להבחין בין השמה להשוואה:

• score = 10 — השמה: שומרת את הערך 10 במשתנה.
• score == 10 — השוואה: בודקת אם הערך שבמשתנה שווה ל־10, בלי לשנות אותו.

האופרטור != בודק אי־שוויון, > בודק „גדול מ־” ו־< בודק „קטן מ־”. גם >= („גדול או שווה”) ו־<= („קטן או שווה”) מחזירים ערך בוליאני.

score = 10
print("score == 10:", score == 10)
print("score == 7:", score == 7)
print("score != 7:", score != 7)
print("score > 5:", score > 5)
print("score < 5:", score < 5)
print("score >= 10:", score >= 10)
print("score <= 7:", score <= 7)
print("Score after comparisons:", score)

פלט

score == 10: True
score == 7: False
score != 7: True
score > 5: True
score < 5: False
score >= 10: True
score <= 7: False
Score after comparisons: 10

השורה האחרונה מראה שההשוואות לא שינו את score. אפשר גם לשמור את תוצאת ההשוואה במשתנה בוליאני:

score = 10
has_won = score == 10
print("Has won:", has_won)

פלט

Has won: True

ב־has_won = score == 10 מחשבים תחילה את ההשוואה שבצד ימין, ואז שומרים את תוצאתה במשתנה שבצד שמאל. בהמשך נשתמש בערכים בוליאניים כדי לבחור אילו הוראות לבצע.

פעולות חשבון ועדכון משתנה

הסימנים +, - ו־* משמשים לחיבור, לחיסור ולכפל. אפשר לחשב ולהציג תוצאה ישירות, למשל print(8 + 3) או print(8 - 3).

כדי לעדכן משתנה מספרי, אפשר להשתמש בכתיבה הארוכה או בקיצור: score += 5 זהה ל־score = score + 5, ו־count -= 1 זהה ל־count = count - 1.

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

print(8 + 3)
print(8 - 3)

score = 10
score = score + 5
print(score)

score = 10
score += 5
print(score)

count = 3
count = count - 1
print(count)

count = 3
count -= 1
print(count)

פלט

11
5
15
15
2
2

שתי דרכי ההוספה משנות את score מ־10 ל־15; שתי דרכי ההפחתה משנות את count מ־3 ל־2. בוחרים אחת מדרכי הכתיבה לכל עדכון.

הערות

הערות מסבירות את הקוד לקורא. הערה מתחילה ב־# ונמשכת עד סוף השורה; פייתון מתעלמת מהתוכן שלה בזמן הרצת הקוד. אפשר לכתוב הערה בשורה נפרדת או אחרי פקודה.

# Initial number of lives
lives = 3
score = 10  # Starting score

# Add the bonus to the score.
# Each coin is worth 5 points.
score += 5
print(score)

פלט

15

ההערות אינן מופיעות בפלט. להערה הנמשכת כמה שורות מוסיפים # בתחילת כל שורה.

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

בתחילת קובץ, לפני הפקודות, מחרוזת כזאת משמשת מחרוזת תיעוד (docstring) המתארת את התוכנית:

'''
Calculate the player's score.
Add a bonus for collecting a coin.
'''
score = 10
score += 5
print(score)

פלט

15

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

קלט ופלט

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

אפשר להעביר ל־print כמה פריטים המופרדים בפסיקים. למשל, ב־print("Sum:", first + second) הפריט הראשון הוא טקסט המתאר את התוצאה, והפריט השני הוא הערך המחושב. print מציגה אותם באותה שורה ומוסיפה ביניהם רווח כברירת מחדל. הפסיק עצמו אינו מודפס, ואין צורך להמיר את המספר למחרוזת.

first = input("First number: ")
second = input("Second number: ")
print("Joined text:", first + second)

אם נקליד 23 ו־35, ההדפסה האחרונה תהיה צירוף שתי המחרוזות:

פלט

Joined text: 2335

לחישוב מספרי ממירים את הקלט:

first = int(input("First number: "))
second = int(input("Second number: "))
print("Sum:", first + second)

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

פלט

Sum: 58

לקליטת מספר ממשי משתמשים ב־float:

speed = float(input("Speed: "))
print("Double speed:", speed * 2)

אם נקליד 3.5, ההדפסה האחרונה תציג את המהירות הכפולה:

פלט

Double speed: 7.0

התוויות מבהירות מה מוצג בכל הדפסה: Joined text — צירוף טקסט, Sum — סכום מספרי, ו־Double speed — מהירות כפולה. כאן מניחים שהקלט מתאים לטיפוס המבוקש.

שילוב ערך בתוך טקסט

בסעיף הקודם הפרדנו בין הטקסט לערך בעזרת פסיק בתוך print. לעיתים נוח יותר לבנות את ההודעה כולה כמחרוזת אחת, למשל כדי לשמור אותה במשתנה או להציג אותה על מסך המשחק. כדי ליצור הודעה המשלבת טקסט וערכים, מוסיפים f לפני המירכאות וכותבים את המשתנה בתוך {}. זו מחרוזת מעוצבת — f-string:

score = 10
message = f"Score: {score}"
print(message)

פלט

Score: 10

הערך של score משתלב במחרוזת בזמן יצירתה. בהמשך נשתמש באותה דרך לתיאור אובייקטים. מחרוזות מעוצבות בתיעוד Python.

שמות ברורים והמרות

שמות רגישים לאותיות גדולות: score ו־Score הם שמות שונים. בחרו שם שמתחיל באות או בקו תחתון, בלי רווחים; למשל player_score. אין להשתמש במילה שמורה כגון if. המספר 123 והמחרוזת "123" אינם אותו סוג נתון.

int ממירה למספר שלם, float למספר עשרוני ו־str למחרוזת. המרת מספר עשרוני ל־int משמיטה את החלק השברי, ולא מעגלת לקרוב ביותר:

print(int(3.9))
print(float("3.5"))
print(str(12) + " points")

פלט

3
3.5
12 points

חילוק, שארית וחזקה

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

number = 352
print(number % 10)
print(number // 10)
print(7 / 2, 7 // 2, 2 ** 3)
print(-7 // 2)

פלט

2
35
3.5 3 8
-4

במספרים שליליים עיגול כלפי מטה שונה מהשמטת החלק השברי: -3.5 מעוגל כאן ל־-4.

סדר פעולות החשבון וסוגריים

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

1. סוגריים מקבצים את החישוב שרוצים לבצע תחילה.
2. חזקה — **.
3. כפל, חילוק ושארית — *, /, //, %, באותה קדימות.
4. חיבור וחיסור — +, -, באותה קדימות.

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

print("2 + 3 * 4:", 2 + 3 * 4)
print("(2 + 3) * 4:", (2 + 3) * 4)
print("20 / 5 * 2:", 20 / 5 * 2)
print("20 / (5 * 2):", 20 / (5 * 2))
print("2 * 3 ** 2:", 2 * 3 ** 2)
print("(2 * 3) ** 2:", (2 * 3) ** 2)

פלט

2 + 3 * 4: 14
(2 + 3) * 4: 20
20 / 5 * 2: 8.0
20 / (5 * 2): 2.0
2 * 3 ** 2: 18
(2 * 3) ** 2: 36

בשורה הראשונה הכפל נותן 12 ורק אחריו מוסיפים 2; בשנייה הסוגריים גורמים לחיבור להתבצע קודם. בשורה השלישית מחלקים 20 ב־5 ואז כופלים ב־2; ברביעית מחלקים 20 בתוצאת המכפלה שבסוגריים. בשתי האחרונות משווים בין העלאת 3 בריבוע לבין העלאת המכפלה כולה בריבוע.

סוגריים יכולים גם להבהיר את הכוונה, אפילו כשהתוצאה אינה משתנה. למשל, 2 + (3 * 4) מדגישה שהכפל קודם לחיבור.

שולטים בהדפסה

ראינו ש־print מפרידה בין הערכים ברווח ויורדת שורה בסוף. לפעמים רוצים משהו אחר — למשל להדפיס שעה בצורה 12:30, או להמשיך את ההדפסה הבאה באותה שורה. לשם כך ל־print יש שני פרמטרים נוספים: sep קובעת מה יודפס בין הערכים, ו־end מה יודפס בסוף הקריאה. ברירת המחדל היא רווח בין ערכים וירידת שורה בסיום.

print(12, 30, sep=":")
print("Hello", end=" ")
print("world")

פלט

12:30
Hello world

חזרה על טקסט באמצעות כוכבית

כפל מחרוזת במספר שלם חוזר על הטקסט מספר פעמים. למשל, "Ha" * 3 יוצרת את המחרוזת "HaHaHa". אפשר לחזור גם על סימן יחיד כדי ליצור קו מפריד:

print("Repeated text:", "Ha" * 3)
print("*" * 10)

פלט

Repeated text: HaHaHa
**********

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

ירידת שורה וטאב בתוך טקסט

בתוך מחרוזת, \n מציין ירידת שורה. כך אפשר להדפיס שתי שורות בקריאה אחת ל־print:

print("First line\nSecond line")

פלט

First line
Second line

הרצף \t מציין טאב — מעבר לנקודת הטאב הבאה בשורה. הוא שימושי להפרדה בין פריטים:

print("Name\tScore")
print("Dana\t10")

פלט

Name	Score
Dana	10

הרוחב החזותי של טאב תלוי בסביבת התצוגה ובמיקומו בשורה; הוא אינו מספר קבוע של רווחים. את \n ואת \t כותבים בתוך המירכאות, עם לוכסן הפוך (\).