טיפוסים מספריים: int וfloat

אג’נדה

• העמקה בטיפוסים int ו-float

• אופרטורים מספריים מתקדמים: מודולו (%) חילוק ללא שארית (//) וחזקה (**)

• משתנים והשמות

• פעולות השוואה

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

חשוב להבין שמבחינת פייתון, מספרים עם נקודה עשרונית ומספרים שלמים אינם אותו דבר – הם שייכים לטיפוסי נתונים שונים. מספרים שלמים, כמו 4, 0 או 56 המשתייכים למחלקה בשם int, שהיא קיצור של המילה integer באנגלית, שפירושה “מספר שלם”. לעומתם, מספרים הכוללים נקודה עשרונית, כמו 3.14, משתייכים למחלקה אחרת בשם float, קיצור של floating point. השם מתאר את צורת הייצוג של המספרים הללו במחשב – ייצוג שבו הנקודה העשרונית יכולה “לצוף” ולהופיע במיקומים שונים בהתאם לערך המספר.

נבחן דוגמא קונקרטיות: על מנת לייצג מספר עשרוני – למשל לייצג 0.1 – נשתמש בfloat. אך חשוב לדעת שמספרים כאלה סובלים מבעיית דיוק, כך שחישוב כמו 0.1+0.1+0.1 לא תמיד יניב את התוצאה המדויקת שציפינו לה (0.3), אלא תוצאה מקורבת (לדוגמא, 0.29999998 או 0.300000001). בקורס הזה לא נעמיק בסיבות לכך, אבל כן נדגיש שאם מספיק לנו לעבוד עם מספרים שלמים, כדאי להישאר עם טיפוס שמתאים לכך, כדי להימנע מהבעיות האלה, וכדי לחסוך בזכרון וזמן ריצה.

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

החזרת הטיפוס של משתנה

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

n=10
print(n, type(n)) 
n = 1.3141
print(n, type(n)) 

10 <class 'int'>
1.3141 <class 'float'>

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

שילוב int ל-float באותו אופרטור

כיוון שגם מספרים שלמים (int) וגם מספרים עשרוניים (float) הם סוגי נתונים מספריים, פייתון יודעת לשלב ביניהם בצורה טבעית בתוך אותו ביטוי. כאשר מופיעים יחד ערכים משני הטיפוסים, פייתון מבצעת המרה אוטומטית כך שהתוצאה תהיה מטיפוס float. הסיבה לכך היא שטיפוס float גמיש יותר ומסוגל לייצג גם מספרים עם נקודה עשרונית וגם מספרים שלמים. למשל, בביטוי 1 + 2.5 מתקבל הערך 3.5, שהוא מספר מטיפוס float.

חשוב לשים לב ש-float עשוי להופיע גם במקרים שבהם הביטוי מכיל אך ורק מספרים שלמים. לדוגמה, אם נחשב 10/4, נקבל את התוצאה ‎2.5‎ – מספר עשרוני מטיפוס float. אפילו במקרה של חלוקה “מדויקת”, כמו 10/2, נקבל את ‎5.0‎, שהוא גם כן float. המשמעות היא שכל פעולת חילוק בפייתון, ללא קשר לערכים המעורבים, מחזירה תוצאה מטיפוס float. בהמשך נלמד גם על אופרטורים נוספים שיכולים להחזיר תוצאה שלמה, במידה ונרצה בכך.

אופרטורים מספריים נוספים

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

חילוק ללא שארית - //

נותן רק את החלק השלם של תוצאת החלוקה. כלומר את מנת החלוקה, מעוגלת למטה. למשל, כאשר מחלקים 10/4, התוצאה היא 2.5. החלק השלם של התוצאה הוא 2, או במילים אחרות 4 נכנס ב-10 פעמיים שלמות (ונשארת עוד שארית של 2). כאשר מחשבים 4//10 מקבלים רק את המנה, כלומר 2.

להלן מספר דוגמאות שדרכן נבין את ההבדל בין / ל//. הוסיפו פקודות דומות אם אתם מעוניינים לראות עוד דוגמאות:

# Division examples
print(10/4, 10//4)
print(10/3, 10//3)
print(3/4, 3//4)

2.5 2
3.3333333333333335 3
0.75 0

modulo - %

נותן את שארית החלוקה. כלומר מה שנשאר אחרי החלוקה השלמה. לדוגמא, כשמבצעים 3//11 מקבלים 9, ונשאר 2 שלא הצלחנו לחלק.

דוגמאות נוספות:

print(11%3)
print(10%4)
print(3%4)

2
2
3

חזקה - **

פעולת החזקה המוכרת מסומנת על ידי **. לדוגמא, כשמבצעים 3**2 נחשב בעצם 2 בחזקת 3 ונקבל 8.

דוגמאות נוספות:

print(4**3)
print(3**0)

64
1

בחנו את עצמכם

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

סיכום פעולות אריתמטיות

אופרטור	שימוש	תיאור
+	x + y	סכום של x ו־y
-	x - y	חיסור y מ־x
*	x * y	כפל של x ב־y
**	x ** y	חזקה של x בחזקת y
/	x / y	חילוק של x ב־y
//	x // y	חילוק שלם של x ב־y: מחזיר את החלק השלם (מעוגל למטה) של תוצאת החילוק
%	x % y	מודולו: השארית של החילוק של x ב־y

השוואות בין מספרים

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

בסרטון זה למדנו את הדרכים להשוות בין מספרים בפייתון:

• בדיקה אם מספר קטן ממש או גדול ממש ממספר אחר<, >

• בדיקה אם מספר קטן (או גדול) ממספר אחר או שווה לו =>.

• בדיקה אם שני מספרים הם שווים == - ושמנו לב להבדל מפעולת ההשמה בפקודה =

• בדיקה אם שני מספרים שונים אחד מהשני =!

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

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

#print(3 < 4)
#print(3 > 4)
x = 3
y = 4
# print(x*2 < y  + 1)
# print(x==y)
# print(x+1 == y)
# x = y
# print(x)
# print(y)a
# print(3 != 4)
# print(3 <= 4)
# print(3 <= 3)
# print(3 >= 4)
print(3 >= 3)

True

בחנו את עצמכם

לפניכם קטע קוד ובו 3 משתנים - x,y,z. המשתנים מאותחלים ל-0. לאחר אתחול המשתנים, ישנן מספר הדפסות של פעולות השוואה הכוללות את המשתנים הנ”ל. עליכם לשנות את ערכם של x,y,z עד שכל ההדפסות מדפיסות True.

רמז:

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

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

x = 0
y = 0
z = 0


print(x + y < z)
print(3*x == 2*y)
print(z < 20)
print(x + 1 == 6)
print(y / 3 >= 2)

False
True
True
False
False

פייתון יודע להשוות בין מספר מסוג int למספר מסוג float:

print(5==5.0)
print(5 < 5.7)

True
True

כפי שציינו קודם, כאשר מבצעים השוואה בפייתון, התוצאה היא ערך מטיפוס בוליאני (bool) – כלומר True או False. זהו טיפוס נתונים בפני עצמו, בדיוק כמו מספרים (int,float). ניתן לשמור ערכים בוליאניים במשתנים:

x=3<3
print(x, type(x))

False <class 'bool'>

במודול הבא, נראה פעולות נוספות שניתן לבצע באמצעות הטיפוס bool.

סיכום אופרטורי השוואה

משווים בין משתנים ומחזירים ערך בוליאני (True / False)

אופרטור	שם	תיאור
x < y	קטן מ־	אמת אם x קטן מ־y, אחרת שקר.
x > y	גדול מ־	אמת אם x גדול מ־y, אחרת שקר.
x <= y	קטן או שווה ל־	אמת אם x קטן או שווה ל־y, אחרת שקר.
x >= y	גדול או שווה ל־	אמת אם x גדול או שווה ל־y, אחרת שקר.
x == y	שווה	אמת אם x שווה ל־y, אחרת שקר.
x != y	שונה	אמת אם x שונה מ־y, אחרת שקר.