טיפוסי נתונים ב-Python: int, float, str, bool, list, dict ועוד

למה טיפוסים בכלל חשובים

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

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

מספרים: int ו-float

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

whole = 42
fractional = 3.14

print(type(whole))
print(type(fractional))

אין נקודה עשרונית? מקבלים int. יש נקודה עשרונית? מקבלים float. אפשר לערבב ביניהם בחופשיות בחישובים: כל פעולה שמעורב בה float מחזירה float:

print(10 + 3)       # int + int  -> int
print(10 + 3.0)     # int + float -> float
print(10 / 3)       # / תמיד מחזיר float ב-Python 3
print(10 // 3)      # // הוא חילוק שלמים (משמיט את השארית)
print(10 % 3)       # % הוא מודולו (השארית)
print(2 ** 8)       # ** הוא חזקה

מספרים שלמים ב-Python יכולים להיות גדולים ככל שהזיכרון מאפשר: אין גלישה, ואין תקרה קבועה של 32 או 64 ביט. אפשר לחשב 2 ** 1000 ו-Python תחזיר כל ספרה וספרה.

מספרי float פועלים לפי כללי IEEE 754 הרגילים, ולכן יש כמה הפתעות קלאסיות:

print(0.1 + 0.2)

זה מדפיס 0.30000000000000004, לא 0.3. זה לא באג ב-Python: כך עובדת נקודה צפה בינארית בכל שפה. כשצריך ערכים עשרוניים מדויקים (למשל כסף), השתמשו במודול decimal. לכל השאר, עיגול בזמן התצוגה בדרך כלל מספיק.

מחרוזות: str

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

first = "double-quoted"
second = 'single-quoted'
mixed = "I'm fine either way"
print(first, second, mixed)

מחרוזות במירכאות משולשות (""" ... """) יכולות להשתרע על פני כמה שורות:

message = """Dear reader,

Thanks for sticking with Python so far. It gets more fun from here.

Signed,
The docs"""
print(message)

למחרוזות יש API עצום שתלמדו עם הזמן: חיתוך, מתודות כמו .upper(), .split() ו-.replace(), ועיצוב f-string שנותן לכם f"Hello, {name}". יש עמוד ייעודי על מחרוזות מיד בהמשך.

בוליאנים: bool

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

ready = True
dry = False

print(5 > 3)
print(5 == 5)
print(ready and not dry)

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

checks = [5 > 3, 10 == 10, 0 > 1]
print(sum(checks))

None: היעדר ערך

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

selected = None

if selected is None:
    print("Nothing picked yet")
else:
    print("You picked", selected)

המוסכמה היא לבדוק עם is None ו-is not None, ולא עם == None. is בודק זהות, וזה מה שבאמת מתכוונים אליו כאן.

רשימות, tuples, קבוצות ומילונים

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

a_list = [1, 2, 3]            # מסודרת, ניתנת לשינוי
a_tuple = (1, 2, 3)           # מסודר, לא ניתן לשינוי
a_set = {1, 2, 3}             # לא מסודרת, בלי כפילויות
a_dict = {"name": "Ada", "age": 36}  # זוגות של מפתח -> ערך

print(a_list, a_tuple, a_set, a_dict)

כללי אצבע:

• List: רצף שאתם מצפים שישתנה. הוספה, הסרה, מיון: הכל בסדר.
• Tuple: רצף שאתם רוצים להגן עליו משינוי. משמש הרבה לרשומות בצורה קבועה, כמו קואורדינטות (x, y).
• Set: שק של פריטים ייחודיים, כשכפילויות יהיו באג.
• Dict: חיפוש לפי מפתח. המבנה בצורת JSON.

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

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

age = 30
message = "You are " + str(age) + " years old"
print(message)

value = int("42") + 1
print(value)

pi = float("3.14")
print(pi)

אם המרה לא הגיונית, למשל int("hello"), Python זורקת ValueError ואומרת לכם מה העברתם לה. שגיאה, הסבר, מתקנים וממשיכים.

בדיקת טיפוס

שני כלים שכדאי להכיר:

print(type(10))              # <class 'int'>
print(type("hi"))            # <class 'str'>

print(isinstance(10, int))   # True
print(isinstance(10, (int, float)))  # True: מתאים לכל אחד מהם

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

תרגיל סקירה קצר

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

values = [42, 3.14, "python", True, None, [1, 2], (1, 2), {1, 2}, {"k": "v"}]

for v in values:
    print(v, "->", type(v).__name__)

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

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

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

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