המאפיינים החדשים של פייתון

מאמר זה מסביר את המאפיינים החדשים ביותר של פייתון.

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

YouTube Video

המאפיינים החדשים של פייתון

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

שיפורים דרמטיים בהודעות השגיאה (פייתון 3.12)

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

1def calc_total(price, tax):
2    return price + price * tax
3
4result = calc_total(100, )

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

שימוש מעשי בפקודת 'match' (התאמה מבנית של תבניות)

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

1user = {"status": "active", "name": "Alice"}
2
3match user:
4    case {"status": "active", "name": name}:
5        print(f"Welcome back, {name}!")
6    case {"status": "inactive"}:
7        print("Please activate your account.")
8    case _:
9        print("Unknown user status.")

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

התאמת תבניות אינטואיטיבית לטיפול בנתונים מקוננים

פקודת 'match' יעילה גם עבור נתונים מבניים כמו JSON או תגובת API.

1data = {"user": {"name": "Bob", "age": 25}}
2
3match data:
4    case {"user": {"name": name, "age": age}}:
5        print(f"{name} is {age} years old.")

• ניתן לחלץ רק את הרכיבים הנחוצים בבטחה, וכך להפחית בצורך בקוד מגן.

פלט דיבוג משופר של f-string (תווי =` / פייתון 3.8 ומעלה, שיפור שימושיות)

באמצעות f-strings, ניתן כעת להוסיף = כדי להציג גם את הביטוי וגם את תוצאתו בו-זמנית. פיצ'ר זה מיועד לדיבוג ומועיל במיוחד כשאתם רוצים לבדוק במהירות את תוכן המשתנה.

1x = 10
2y = 20
3print(f"{x=}, {y=}, {x+y=}")

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

הפשטת Type Hints ו'שם סוג' ('type') (פייתון 3.12: תחביר חדש לשמות טיפוס)

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

1type UserId = int
2type UserName = str
3
4def greet(user_id: UserId, name: UserName) -> str:
5    return f"Hello, {name} (id={user_id})"

• מתן משמעות לUserId או UserName מבהיר את ההבדלים בתפקיד, גם אם שניהם משתמשים באותו טיפוס int או str.
• הגדרת הטיפוסים נעשית תמציתית יותר, וכך קל יותר להבין בקוד רוויו ותחזוקה.
• בעבר, שמות טיפוס כמו UserId = int הוגדרו על ידי השמה, אך שימוש ב-type מבהיר 'שזו הגדרת טיפוס'. זה יעיל במיוחד לשיפור קריאות התכנון בקוד בסיס בגודל בינוני וגדול.

הערות טיפוס טבעיות בשימוש טיפוסים מובנים (גנריות מופשטות מפייתון 3.9+)

החל מפייתון 3.9, ניתן להשתמש בטיפוסים כמו list או dict ישירות כגנריים.

כך אפשר לכתוב רמזי טיפוס אינטואיטיביים וקריאים בלי לייבא טיפוסים מהמודול typing.

1def sum_numbers(numbers: list[int]) -> int:
2    return sum(numbers)
3
4print(sum_numbers([1, 2, 3, 4]))

• רמזי טיפוס משמשים לא כהגבלות, אלא כ'תיעוד המסביר את תוכן התהליכים'.

השרשור בטוח של מתודות עם 'Self' (פייתון 3.11 ומעלה)

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

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

 1from typing import Self
 2
 3class Counter:
 4    def __init__(self, value: int = 0) -> None:
 5        self.value = value
 6
 7    def increment(self) -> Self:
 8        self.value += 1
 9        return self
10
11counter = Counter()
12counter.increment().increment()
13print(counter.value)

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

מניפולציית מחרוזות ברורה יותר (removeprefix / removesuffix | פייתון 3.9 ומעלה)

מפייתון 3.9 נוספו המתודות str.removeprefix() ו-str.removesuffix() להסרה בטוחה של תחיליות וסיומות ממחרוזות. באמצעותן ניתן לבטא במדויק את הכוונה 'להסיר רק את ההתחלה או הסוף' בקוד שלכם.

1filename = "report_2026.txt"
2
3clean_name = filename.removeprefix("report_")
4name_without_ext = clean_name.removesuffix(".txt")
5
6print(name_without_ext)

• המחרוזת שצוינה מוסרת רק אם היא מופיעה בתחילה או בסוף, כך שנמנעות החלפות לא-רצויות.
• גישה זו מעניקה קריאות ובטיחות יותר מהשימוש ב-replace() או חיתוך.
• בעיקר בטיפול 'במחרוזות בפורמט מוגדר' (למשל שמות קבצים או עיבוד כתובות URL), השימוש בשיטות האלו מפחית מאוד את הסיכון לבעיות תוכנה.

השוואת מחרוזות חזקה לאינטרנשיונליזציה (str.casefold() | תמיכה ביוניקוד)

str.casefold() בפייתון היא מתודה להשוואה ללא הבחנת אותיות, תוך התחשבות בתווי Unicode. שלא כמו lower() או upper(), המתודה מנרמלת את המחרוזת באופן שכולל המרות תווים לשם שפות מסויימות.

1text1 = "Stra\u00dfe"
2text2 = "strasse"
3
4print(text1)
5print(text2)
6
7print(f"Comparison Result: {text1.casefold() == text2.casefold()}")

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

תמיכת TOML תקנית (tomllib | פייתון 3.11 ומעלה)

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

 1import tomllib
 2
 3with open("config.toml", "rb") as f:
 4    config = tomllib.load(f)
 5
 6print(config["database"]["host"])
 7
 8# config.toml
 9# title = "TOML Example"
10# [database]
11# host = "192.168.1.1"
12# ports = [ 8001, 8001, 8002 ]

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

טיפול חריגות לעידן עיבוד מקבילי (ExceptionGroup / except* | פייתון 3.11 ומעלה)

פייתון 3.11 הציגה ExceptionGroup לטיפול במספר חריגות יחד וסינטקס except* לטיפול בטוח בהסתעפויות. זו תכונה חדשה לטיפול ב'שגיאות בו־זמניות' שמתרחשות בעיבוד אסינכרוני או מקבילי.

 1def process(values):
 2    errors = []
 3    for v in values:
 4        if v < 0:
 5            errors.append(ValueError(f"Negative value: {v}"))
 6    if errors:
 7        raise ExceptionGroup("Invalid values", errors)
 8
 9try:
10    process([1, -2, -3])
11except* ValueError as e:
12    print("Handled:", e)

• ניתן כיום להעלות ולסווג כמה חריגות בפעולה אחת.
• זה פותר את הבעיה שבעיבוד אסינכרוני ניתן היה להבחין רק בשגיאה הראשונה.
• בפעולות כמו asyncio.gather() או עיבוד אצווה מקבילי, יכולים להתרחש כמה כשלים יחד. השימוש ב־ExceptionGroup מקל על ארגון איסוף שגיאות, לוגים ואסטרטגיות רה-נסיון.

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

החל מפייתון 3.11, תהליכים רבים הואצו בזכות אופטימיזציות פנימיות.

1def count_up(n):
2    total = 0
3    for i in range(n):
4        total += i
5    return total
6
7print(count_up(1_000_000))

• יתרון עיקרי הוא אפשרות לשפר מהירות מבלי לכתוב מחדש אף שורת קוד.

שליטה בניהול זיכרון (בקרת איסוף אשפה דרך מודול gc)

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

1import gc
2
3gc.disable()
4# heavy batch processing
5gc.enable()
6gc.collect()

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

סיכום

עם שיפורים בהודעות שגיאה והתפתחות הרמזים הטיפוסים בין פייתון 3.12 ל-3.13, הבנה ותחזוקת קוד הפכו לקלים מאי פעם. בנוסף, שיפורים כגון חוויות דיבוג טובות יותר ושיפורי ביצועים פנימיים משפרים בפועל את התפוקה. אין צורך להשתמש בכל הפיצ'רים החדשים בבת אחת; עדיף להתחיל עם הגרסה העדכנית של פייתון ולהטמיע בהדרגה את מה שדרוש. אימוץ הדרגתי מוביל לקוד פייתון קריא ומוצק יותר.

תוכלו לעקוב אחר המאמר שלמעלה באמצעות Visual Studio Code בערוץ היוטיוב שלנו. נא לבדוק גם את ערוץ היוטיוב.

YouTube Video