מספרים ובוליאנים ב-Python: int, float, bool וחשבון

שני סוגי מספרים, סוג אחד של אמת

הטיפוסים המספריים שתשתמשו בהם ביום-יום הם int ו-float, ובנוסף bool לערכי אמת ושקר. הם מספיקים כמעט לכל החשבון והלוגיקה שתוכנית Python רגילה צריכה.

count = 42
ratio = 0.25
is_ready = True

print(type(count), type(ratio), type(is_ready))

Python מתייחסת לבוליאנים כתת-טיפוס של מספרים שלמים: True הוא ממש 1 ו-False הוא ממש 0, וזה פותח בהמשך כמה טריקים שימושיים.

חשבון עם מספרים שלמים

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

print(2 ** 100)
print(1000 * 1000 * 1000 * 1000)

שתי השורות מפיקות תשובות מדויקות, לא משנה כמה גדולות. הזיכרון הוא התקרה היחידה.

האופרטורים האריתמטיים הם מה שהייתם מצפים, ועוד כמה:

print(10 + 3)   # 13   חיבור
print(10 - 3)   # 7    חיסור
print(10 * 3)   # 30   כפל
print(10 / 3)   # 3.3333... חילוק אמיתי (מחזיר float)
print(10 // 3)  # 3    חילוק שלם (משמיט את השארית)
print(10 % 3)   # 1    מודולו (השארית)
print(10 ** 3)  # 1000 חזקה

שלושה דברים שכדאי לזכור מהרשימה הזו:

• / תמיד מחזיר float ב-Python 3, גם כששני הצדדים מספרים שלמים. 10 / 2 נותן 5.0, לא 5. אם אתם רוצים מספר שלם, השתמשו ב-//.
• // מעגל כלפי מינוס אינסוף, כך ש--7 // 2 הוא -4, לא -3. לא שגרתי, אבל עקבי.
• % נותן את השארית, והוא שימושי לשאלה "האם המספר זוגי?" (n % 2 == 0) ולגלגול בתוך טווח קבוע.

Floats והמלכודת המפורסמת שלהם

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

print(0.1 + 0.2)
print(0.1 + 0.2 == 0.3)

השורה הראשונה מדפיסה 0.30000000000000004. השנייה מדפיסה False. לכל שפה שפועלת לפי תקן IEEE 754, כמו Python, JavaScript, Java ו-C, יש את ההתנהגות הזו. זה לא באג ב-Python.

בפועל זה אומר שני דברים:

1. אל תשוו floats עם ==. אם אתם צריכים "קרוב מספיק", השתמשו ב-math.isclose(a, b) או בדקו אם abs(a - b) < some_tolerance.
2. לכסף, השתמשו ב-decimal.Decimal. המודול decimal מהספרייה הסטנדרטית נותן חשבון עשרוני מדויק, בלי הפתעות כמו 0.1 + 0.2. הוא איטי יותר מ-float, ולכן הוא לא ברירת המחדל, אבל הוא הבחירה הנכונה למטבע.

from decimal import Decimal

total = Decimal("0.1") + Decimal("0.2")
print(total)

המרה בין טיפוסי מספרים

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

age_text = "30"
age = int(age_text)
print(age + 5)

price = float("19.99")
print(price)

count = 7
label = "Count: " + str(count)
print(label)

המרות לא תקינות זורקות ValueError:

>>> int("hello")
ValueError: invalid literal for int() with base 10: 'hello'

הודעת השגיאה ישירה וקל לפעול לפיה. נקו את הקלט או תפסו את החריגה.

בוליאנים, קצת יותר לעומק

True ו-False הם שני הערכים הבוליאניים, ונכתבים בדיוק כך, עם אות ראשונה גדולה. רוב ההשוואות מפיקות אחד מהם:

print(5 > 3)
print("abc" == "abc")
print([1] != [1])

האופרטורים הבוליאניים הם and, or ו-not, שנכתבים כמילים באנגלית ולא כסימנים:

can_drive = True
has_car = False

print(can_drive and has_car)   # False: צריך את שניהם
print(can_drive or has_car)    # True: צריך אחד
print(not can_drive)           # False

דקות אחת שכדאי להכיר: and ו-or לא בהכרח מחזירים True או False. הם מחזירים את הערך שהכריע את הביטוי. 0 or "fallback" מחזיר "fallback", ו-5 and 10 מחזיר 10. זה מאפשר לכתוב ערכי ברירת מחדל קצרים כמו name = user_input or "anonymous", אבל כדאי להבין את זה גם למקרה שבדיקה בוליאנית תחזיר לכם טיפוס לא צפוי.

Truthy ו-Falsy

Python מתייחסת לערכים רבים כ"כמעט אמת" או "כמעט שקר" כשמשתמשים בהם בהקשר בוליאני כמו if או while. הערכים ה-falsy הם:

• False
• 0, 0.0
• None
• מכולות ריקות: "", [], {}, set(), ()

כל השאר truthy. זה מאפשר לכתוב בדיקות שנראות טבעיות יותר:

name = ""

if name:
    print(f"Hello, {name}")
else:
    print("No name provided")

קראו את if name: כ"אם יש משהו ב-name". הרבה יותר נקי מ-if name != "":. רק היזהרו עם מספרים: if count: יתייחס ל-0 כ"דלג", וזה בדרך כלל, אבל לא תמיד, מה שרוצים. אם אפס הוא ערך לגיטימי, השתמשו ב-if count is not None: במקום.

חשבון עם בוליאנים

מכיוון שבוליאנים הם מספרים שלמים, אפשר לבצע עליהם חשבון:

checks = [True, False, True, True, False]
print(sum(checks))   # 3: סופר כמה מהם True

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

scores = [52, 78, 91, 45, 88, 63]
above_60 = sum(score >= 60 for score in scores)
print(above_60)

השורה התחתונה

• מספרים שלמים אף פעם לא גולשים. השתמשו בהם בחופשיות.
• / מחזיר float, השתמשו ב-// כשרוצים חילוק שלם.
• אל תשוו floats עם ==: השוו עם סבולת, או השתמשו ב-Decimal לכסף.
• truthiness הופכת תנאים לקריאים יותר, כל עוד זוכרים ש-0 ומחרוזות ריקות הם falsy.

הבא בתור: input ו-print, שני הכלים שהופכים את הסקריפטים שלכם מתוכניות שקטות לשיחות.