פייתון

מתוך ויקיפדיה, האנציקלופדיה החופשית
(הופנה מהדף Python)
קפיצה אל: ניווט, חיפוש
Python
Python logo and wordmark.svg
פרדיגמות מונחית-עצמים, פרוצדורלית, פונקציונלית
מתכנן גואידוֹ ואן רוֹסוּם (הגיה - קישור חיצוני)
מפתח קרן התוכנה של פייתון‏[1]
גרסה אחרונה 3.4.1 ב-19 במאי 2014 (לפני 5 חודשים ויומיים),
2.7.8 ב-1 ביוני 2014 (לפני 4 חודשים ו־20 ימים)
טיפוסיות דינמית (טיפוסיות ברווז), חזקה, מובלעת
מימושים מפרשים: CPython, IronPython, Jython, Python for S60, PyPy, Unladen Swallow
ניבים Stackless, RPython
הושפעה על ידי ABC, ‏ALGOL 60,‏ Perl,‏ Scheme,C,‏ Java, ‏ Haskell,‏ LISP, Icon
השפיעה על #C‏, Boo‏, Cobra,‏D,‏ Falcon‏, Groovy, Ruby, ‏JavaScript
אתר www.python.org
סיומת py, .pyw, .pyc, .pyo, .pyd.

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

פייתון היא שפה מרובת-פרדיגמות, המאפשרת תכנות מונחה-עצמים, תכנות פרוצדורלי, ובמידה מסוימת גם תכנות פונקציונלי. לשפה ספרייה סטנדרטית גדולה וענפה, והיא תומכת באופן מובנה בהרחבה שלה אל שפות אחרות (בתלות במפרש: C‏, ++C,‏ Java‏ ו#C).

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

שם השפה "פייתון" נבחר כמחווה לחבורה הקומית "מונטי פייתון".

עיצוב ופיתוח[עריכת קוד מקור | עריכה]

גואידו ואן רוסום, ממציא השפה

השפה נוצרה על ידי גואידו ואן רוסום בתחילת שנות התשעים, במקור בתור פיתוח של שפת התכנות ABC אשר יוכל לטפל בחריגות עבור Amoeba OS. מאז השתנתה השפה בצורה משמעותית, וגם כיום נמשך הפיתוח ומוכנסים שינויים רבים. השפה תומכת באופן מובנה בעדכון גרסאות, ומושם דגש על תאימות-לאחור של גרסאות שונות. עם זאת, גרסה 3 של פייתון איננה תואמת באופן מלא לגרסאות קודמות. (הקוד המופיע בערך זה תואם לגרסה 3.0 ומעלה, ועבור גרסאות ותיקות יותר יש לבצע שינויים מינוריים). זכויות היוצרים על גרסאות פייתון החל מ-2.1 שייכות לקרן התוכנה של פייתון.

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

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

מאפייני השפה[עריכת קוד מקור | עריכה]

המפרש[עריכת קוד מקור | עריכה]

שפת פייתון ממומשת לרוב כשפה מפורשת, בדומה לשפות כמו Scheme. תכונה זו מאפשרת לפתח יישומי פייתון באופן בלתי-תלוי במערכת ההפעלה (בתנאי שלא מבוצעות קריאות מערכת הפעלה בלעדיות). בפועל, המפרש של השפה מבצע הידור חלקי לשפת ביניים (Bytecode), בדומה ל-Java; כך יכול המפרש להריץ את אותו קוד פעמים נוספות באופן מהיר ויעיל יותר. כתוצאה מההידור החלקי, ניתן לקבל הערות הידור לפני הרצת הקוד, בכל הקשור לשגיאות תחביר וכדומה.

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

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

סגנונות תכנות נתמכים[עריכת קוד מקור | עריכה]

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

פייתון מאפשרת ואף מעודדת התבוננות-פנימה (Reflection), ותומכת בתכנות מקבילי ותכנות מוכוון-אירועים באמצעות מודולים מתאימים בספריה הסטנדרטית.

ניהול הזיכרון ויצירת אובייקטים[עריכת קוד מקור | עריכה]

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

אובייקטים מוקצים על גבי הערימה, כאשר הם נוצרים על ידי קריאה למחלקה, למשל (x=str(15 ‏, או על ידי הצבה של ליטרלים בשפה - הכוללים מספרים, מחרוזות, רשימות, מילונים, פונקציות למבדה, או על ידי קריאה לפונקציה שיוצרת אותם. שני מנגנונים נוספים הם List Comprehension ו-Generators, שיתוארו בהמשך.

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

המשמעות התחבירית של ההזחה[עריכת קוד מקור | עריכה]

בשפות רבות אין משמעות תכנותית להזחה כשלעצמה: כל בלוק מוקף בתווי בקרה מיוחדים המסמנים את תחילתו וסופו של הבלוק, אף ללא כל הזחה (סוגריים מסולסלים ב-C או Perl, ו-begin ו-end בפסקל וב-VB). בפייתון, המבנה של בלוקים של קוד בתוכנית נקבע על ידי ההזחה שלהם: עצם הזחת הבלוק מגדירה אותו כבלוק תכנותי שונה, באופן שמזכיר את שיטת העבודה בHaskell. תכונה זו מיועדת לשפר את קריאות התוכנית, בכך שהיא כופה על המתכנת כתיבה בסטנדרט אחיד (פחות או יותר), וחוסכת בקוד.

מאפיינים תחביריים נוספים[עריכת קוד מקור | עריכה]

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

מערכת הטיפוסים[עריכת קוד מקור | עריכה]

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

  • חזקה: לא ניתן להפעיל על משתנה פעולה שלא מוגדרת על הטיפוס אליו הוא שייך. לדוגמה, ניסיון לבצע פעולת חזקה בין שתי מחרוזות - גם אם הן מסמנות מספרים, למשל "5" בחזקת "6" - יגרור שגיאה.
  • דינמית: האובייקטים, ולא המשתנים בשפה, הם שייכים לטיפוס. כל משתנה בשפה יכול להצביע על אובייקט מכל טיפוס. כאשר מגדירים פונקציה, אין הגבלה על סוג הטיפוס שיועבר בכל קריאה אליה. ייתכן שבקריאה אחת יועבר מספר שלם, ובקריאה אחרת תועבר מחרוזת. הטיפוסיות היא "טיפוסיות ברווז" (Duck Typing), דהיינו נקבעת על פי הפעולות אותן ניתן לבצע על המשתנה. אם יש צורך לוודא כי משתנה שהתקבל כפרמטר בפונקציה, לדוגמה, הוא מטיפוס "מספר שלם", יש לבצע בדיקה מפורשת (בדרך כלל בעזרת פקודת assert או if).
  • מובלעת: אין הכרזה על קיום משתנים. שם של משתנה מוגדר אם הוא מופיע בצידה השמאלי של פעולת השמה, כפרמטר לפונקציה, כמשתנה לולאה, כפרמטר לתפיסה של חריגה או בפקודת del. מאפיין זה מאפשר גמישות רבה בכתיבת הקוד, וכתיבת קוד קצר יותר, אך מנגד מקשה על זיהוי ואיתור שגיאות בזמן ההידור, ומקשה על איתור טעויות הקלדה.
  • סמנטיקת התייחסות (Reference): משתנים הם שמות של מצביעים (References) אל אובייקטים, ולא שמות של האובייקטים עצמם. כאשר מתבצעת פעולת השמה בין משתנים בצורה x=y, לא מועתק תוכן האובייקט אליו מצביע y. במקום זה, המשתנה x מוגדר כך שיצביע אל אותו אובייקט אליו מצביע y. פרמטרים לפונקציות מועברים על ידי העתקה של המצביעים אליהם. טכנית זו "קריאה על ידי ערך" (Call by Value) אך רבים (ובהם ממציא השפה) מכנים זאת "קריאה על ידי התייחסות לאובייקט" (Call by Object Reference). קריאה לפונקציה בצורה (foo(x, שבתוכה מבצעים x=5, לא תגרום למשתנה x להתייחס לאובייקט אחר מזה שהוא התייחס אליו קודם.
  • טווח הכרה סטטי (או לקסיקלי): שם של משתנה מוגדר רק בקטעי קוד המוכלים בקטע שבו בוצעה אליו פעולת כריכה. למשל, משתנה בשם x המוגדר בתוך פונקציה אחת לא יהיה קשור בשום דרך למשתנה x המוגדר בפונקציה אחרת.

טיפוסים מובנים בשפה[עריכת קוד מקור | עריכה]

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

  • טיפוס הנתונים int מאחסן מספר שלם. בגרסה 3.0 אוחד טיפוס זה אל תוך long (בגרסאות x.‏2 מספרים מטיפוס long מסומנים באות L בקצה), ואין לו הגבלת גודל (מעבר למה שמאפשר הזיכרון הווירטואלי של המחשב) - אין בשפה כל קושי לחשב את מספר פיבונאצ'י ה-100,000 (בדומה ל-BigInteger בשפת Java).
  • טיפוס הנתונים נקודה צפה (float) מאפשר אחסון ערך מקורב של מספר ממשי באמצעות ייצוג נקודה צפה. טיפוס זה זהה לטיפוס double בשפת C (ולמעשה ברוב המקרים ממומש על ידיו). בנוסף, ניתן לייבא את המודול decimal המאפשר ייצוג של שברים עשרוניים, ונוח יותר לעבודה במקרים בהם הייצוג הזה מדויק יותר (כגון חשבונאות).
  • מספר מרוכב גם הוא נתמך בפייתון (נכתב בצורה 3+4j). טיפוס זה נוסף לשפה בשל השימוש הרב שעושים בו מדענים ומהנדסים, שהם אחת מהקהילות העיקריות המשתמשות בשפה, ועל מנת למנוע מהם את הצורך "להמציא את הגלגל" בכל פעם מחדש.
  • ישנה תמיכה מובנית במחרוזות - str. מחרוזת לא נחשבת לטיפוס סדרתי (ראה בהמשך), כיוון שאין בשפה טיפוס מסוג תו, וההתייחסות לתו בודד היא כאל מחרוזת באורך 1. עם זאת, ניתן לגשת אל כל תו במחרוזת באמצעות גישה לפי אינדקס, כמו בטיפוסים הסדרתיים, וניתן להמיר ביניהם בקלות. המחרוזות הבסיסיות הן בתקן ASCII, אך ישנה תמיכה גם בUnicode. ניתן לכתוב מחרוזות הן בעזרת גרשיים כפולים: "hello" והן בעזרת גרש יחיד: 'hello'. אין כל הבדל בין צורות אלו, אך מקובל להשתמש בגרש יחיד. מחרוזות הנכתבות בין שלושה גרשיים רצופים - """hello""" או '''hello''' - ניתן לפרוש על פני מספר שורות ברצף.

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

בשפה מוגדרים שני טיפוסים סדרתיים: tuple ו-list.

  • הטיפוס tuple הוא ייצוג ממוחשב של N-יה סדורה: רצף קבוע של ערכים מטיפוסים אחרים (כלשהם), המיוצג על פי רוב בתוך סוגריים. לדוגמה (1, 2, 3). טיפוס זה מקל על דימוי של החזרת מספר ערכים מפונקציה בודדת, או ביצוע פעולת החלפה בין משתנים (כך ניתן להחליף בין המשתנים a, b באמצעות הפקודה "a, b = b, a"). גם אובייקט מטיפוס זה איננו ניתן לשינוי, דבר המאפשר שימוש בו כמפתח עבור מילון (ראה בהמשך), בשל היכולת להשתמש בו בטבלת גיבוב.
  • המקבילה למערך בפייתון היא הרשימה (list). טיפוס זה הוא למעשה מערך שגודלו משתנה, באופן שקוף למתכנת, וניתן לגשת אל כל איבר בו על ידי אינדקס. רשימה תוגדר בין סוגריים מרובעים, לדוגמה ['x','y','z']. בניגוד ל-tuple, שתוכנו אינו ניתן לשינוי, ברשימה ניתן לשנות כל אחד מהאיברים, וכן להרחיב אותה או להסיר ממנה איברים. בשל כך, לא ניתן להשתמש ברשימות כמפתחות למילון.
  • המילון (dict), הנקרא לעתים "מערך אסוציאטיבי" או "hash", הוא טיפוס המאפשר מיפוי ממפתחות לערכים. כל מילון כולל קבוצה של זוגות כאלה, וגישה אל איבר על פי המפתח שלו מחזירה את הערך המתאים.
  • הקבוצה (set) היא אוסף של איברים שונים, המאפשר לבצע פעולות כמו איחוד, חיתוך, הפרש, בדיקת שייכות וכדומה. קבוצה ומילון הם טיפוסים הניתנים לשינוי, אך אין בהם סדר מוגדר.

פעולת הגישה לאיברים במילון ובקבוצה ממומשת לרוב בעזרת טבלת גיבוב.

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

מבני בקרה[עריכת קוד מקור | עריכה]

רוב מבני הבקרה הנפוצים נתמכים בפייתון, כאשר החריג הבולט הוא מנגנון switch או case. בדומה לרוב שפות התכנות, פייתון איננה כוללת תמיכה במנגנוני Semi-coroutine, או ב-Continuation.

תנאי[עריכת קוד מקור | עריכה]

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

דוגמה לתחביר של פקודת תנאי הבודקת אם משתנה x הוא זוגי על ידי בדיקת שארית בחלוקה ל-2, ומדפיסה הודעה מתאימה:

if x % 2 == 0:
    print('x is even')
else:
    print('x is odd')

בפקודה זו ניתן לראות את היתרון הגדול שמעניקה ההזחה: לא תיתכן תופעה של else "מידלדל" - כל else קשור בדיוק לפקודת ה-if הרשומה הישר מעליו. זאת בניגוד לשפות כמו C, C++, Java ודומותיהן, שבהן יש צורך להבין את סדר העדיפויות של התנאי. מוקש אחר שאיננו קיים בשפה הוא השגיאה הנפוצה לכתוב = בתנאי במקום ==, ובכך לבצע פעולת השמה במקום השוואה. בפייתון פעולת השמה היא פקודה, Expression, ואיננה יכולה להיחשב לביטוי, Statement, ולכן איננה יכולה להימצא בתוך תנאי, וקוד כזה לא יעבור הידור.

פייתון לא תומכת בבורר מרובה כניסות (בדומה ל-switch בשפת C ודומותיה), אך קיימת מילה שמורה elif המאפשרת לבדוק רצף של תנאים, באופן דומה למנגנון זה:

if x % 2 == 0:
    print('x is even')
elif x % 3 == 0:
    print('x is divisible by 3')
elif x % 5 == 0:
    print('x is divisible by 5')
else:
    print("I don't know what x is")

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

if x % 2 == 0:
    print('x is even')
else:
    if x % 3 == 0:
        print('x is divisible by 3')
    else:
        if x % 5 == 0:
            print('x is divisible by 5')
        else:
            print("I don't know what x is")

בניגוד לשפות רבות אחרות, לפקודה else שימושים בהקשרים אחרים - לולאות וניהול חריגות.

ביטוי תנאי[עריכת קוד מקור | עריכה]

עם הזמן, לאור דרישה של מתכנתים להוסיף גם ביטוי תנאי (בדומה לאופרטור :? בשפות ממשפחת ה-C) הוסף לשפה (החל מגרסה 2.5) אופרטור מהצורה "<expr1> if <condition> else <expr2>". ערכו של ביטוי כזה תלוי בערך האמת של הביטוי האמצעי. דוגמה לשימוש באופרטור הזה, השקולה לדוגמה הקודמת:

print('x is even' if x % 2 == 0 else 'x is odd')

לפני שהוסף האופרטור הזה, השתמשו מתכנתים בעובדה שהערך של פעולות and ו-or בפייתון הוא הערך המשמש בהן, ולאו דווקא ערך מטיפוס bool.

כך ניתן לכתוב ביטוי הדומה לביטוי תנאי בצורה "<condition> and <expr1> or <expr2>". למשל הדוגמה הקודמת תיכתב

print(x % 2 == 0 and 'x is even' or 'x is odd')

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

לולאות[עריכת קוד מקור | עריכה]

לולאת while[עריכת קוד מקור | עריכה]

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

דוגמה לתוכנית השואלת את המשתמש האם הוא אוהב דגים, וממשיכה עד שהמשתמש מכניס את המחרוזת "No"‏[2]:

print('Do you like fish?')
while input() != 'No':
    print('Do you like fish?')

ניתן היה לוותר על השורה הראשונה בקטע הקוד, אילו היה בשפה מבנה do-while המבצע את תוכן הלולאה פעם אחת לפחות. עם זאת, אין בשפה מבנה בקרה כזה. אפשר לדמות את מבנה הבקרה הזה על ידי הצבת התנאי (בצורה הפוכה) בשורה האחרונה בלולאה:

while True:
    print('Do you like fish?')
    if input() == 'No': break

למימוש כזה יש חסרונות, שכן לאחר קריאה לפקודת continue בגוף הלולאה לא יתבצע שיערוך מחדש של התנאי המבוקש, בניגוד למצב בלולאה מהסוג הקודם, בלולאות for, ובלולאות Do-While בשפות אחרות.

לולאת for[עריכת קוד מקור | עריכה]

מבנה נוסף ועיקרי בשפה הוא לולאת for. בלולאה זו מוגדר משתנה, ומתקבלת רשימה (או כל טיפוס שניתן לעבור עליו לפי סדר - "Iterable"). המשתנה מקבל בכל מחזור את ערכו של איבר אחר ברשימה, שוב ושוב עד שמגיעים לסוף הרשימה. מבנה זה אינו דומה ללולאת for בשפות ממשפחת ה-C, ומזכיר מעט את לולאת foreach בשפות אחרות. על מנת לבצע פקודה מספר פעמים מוגדר משתמשים בפונקציה (range(x המחזירה איטרטור העובר על המשתנים בין 0 ל-x (בגרסאות קודמות של השפה החזירה פקודה זו רשימה מתאימה).

דוגמה לשימוש בלולאת for להדפסת ריבועי המספרים בין 0 ל-5, לא כולל 5:

for i in range(5):
    print(i ** 2)

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

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

פקודות יציאה[עריכת קוד מקור | עריכה]

להפסקת ביצוע לולאה בנקודה ספציפית ניתן להשתמש בפקודת break. הפקודה continue מסיימת את המחזור הנוכחי של הלולאה, ועוברת לחישוב ביטוי התנאי מחדש (בלולאת while) או לקידום המשתנה בסדרה (בלולאת for).

בנוסף, מתוך פונקציה ניתן להשתמש בפקודה return המסיימת את ריצת הפונקציה כולה, ומחזירה ערך. לא ניתן לסיים באמצעות return את ריצת התוכנית הראשית, שאיננה נחשבת לפונקציה (בשונה מהמצב בשפות ממשפחת ה-C).

חריגות[עריכת קוד מקור | עריכה]

פייתון תומכת בטיפול בחריגות. במקרה שתוכנית נתקלת בסיטואציה חריגה, על פי רוב שגיאה או נתונים עבורם תוצאת החישוב הרצויה איננה מוגדרת, ניתן "להרים" (או "לזרוק") חריגה באמצעות המילה השמורה raise (מקביל ל-throw בשפות אחרות). החריגה הנזרקת היא אובייקט, שיילכד במעלה הקריאה לפונקציה שזרקה אותו, בבלוק ייעודי מהצורה try ... except, שם יטופל באופן ספציפי. אם חריגה לא נלכדת על ידי המתכנת, היא נלכדת על ידי המפרש.

התחביר של לכידת חריגות הוא מהצורה

try:
    ... # קוד העשוי לזרוק חריגה
except <Exception Type> as <Exception name>:
    ... # <Exception Type> קוד המטפל בחריגה מהטיפוס
else:
    ... # קוד שיתבצע רק אם לא נזרקה חריגה
finally:
    ... # קוד שצריך להתבצע בכל מקרה, בין אם נזרקה חריגה ובין או לא

בפייתון כל שגיאה היא חריגה, וכל שגיאה ניתן ללכוד - חלוקה באפס, שגיאות קלט-פלט, שמות שטרם הוגדרו בקוד, וכו' - למעט שגיאות תחביר. החל מגרסה 3.0, שגיאות המוגדרות על ידי המשתמש צריכות להיות מחלקות היורשות מהמחלקה BaseException - לא ניתן לבצע פעולה כגון "raise "error, כיוון שהמחרוזת "error" היא מטיפוס str שאיננה יורשת מ-BaseException.

פונקציות ותכנות פונקציונלי[עריכת קוד מקור | עריכה]

הפונקציות והשיטות בשפה הן אובייקטים לכל דבר. ישנם 7 סוגים של עצמים ברי-קריאה (callable) בפייתון:

  • פונקציות מובנות ושיטות מובנות. אלה נכתבו בשפת האם של המפרש והוטמעו אל תוך השפה.
  • פונקציות המוגדרות על ידי המשתמש, נכתבות באמצעות שימוש במילה השמורה def.
  • שיטות המוגדרות על ידי המשתמש, נכתבות בדומה לפונקציות, אך מוגדרות בתוך מחלקה. כל השיטות בפייתון הן סטטיות, אך כאשר קוראים לשיטה מתוך אובייקט, בצורה ()x.foo, האובייקט מועבר בתור הארגומנט הראשון. (מקובל לקרוא לו self, המקביל לthis בשפות ממשפחת ++C, אך זו איננה מילת מפתח ולא מילה שמורה).
  • ביטויי למבדא - בעצם פונקציות אנונימיות בנות שורה אחת, המוגדרות תוך שימוש במילה השמורה lambda.
  • מחלקות - כל מחלקה בפייתון היא אובייקט מהטיפוס type, וקריאה אליה באמצעות אופרטור הקריאה לפונקציה () יוצר אובייקט מהטיפוס שלה.
  • כל אובייקט שהוגדרה עבורו השיטה __call__, הוא אובייקט בר-קריאה (פעולה זו מקבילה להעמסה של אופרטור () בשפת ++C).

פונקציות מוגדרות על ידי המשתמש[עריכת קוד מקור | עריכה]

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

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

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

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

העברת הפרמטרים לפונקציה מתבצעת באמצעות מנגנון העברה על-פי-ערך (call by value), אך כיוון שמדובר בסמנטיקת התייחסות, הערך המועבר הוא המצביע אל האובייקט ולא האובייקט עצמו. אי לכך ניתן לשנות בתוך גוף הפונקציה את התוכן של האובייקט שהועבר אליה, אך אי אפשר לשנות את ההתייחסות של המשתנים שהועברו כארגומנטים. הקוד הבא, לדוגמה, מנסה לבצע החלפה בין המשתנים שהועברו כארגומנטים, אך פעולה זאת לא תצליח:

def swap(a, b): #דוגמה לפונקציה שאיננה פועלת
    temp = a
    a = b
    b = temp

קריאה לפונקציה על משתנים a, b כלשהם לא תשפיע עליהם כלל.

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

פונקציות למבדה[עריכת קוד מקור | עריכה]

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

lambda <arguments list> : <expression>

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

for i in filter(lambda x : x % 2 == 0, range(100)):
    print(i)

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

פונקציות למבדא, כמו פונקציות מקוננות, הן סגור (Closure).

התמיכה בפונקציות למבדא בפייתון היא חלק מהתמיכה של פייתון בטכניקות של תכנות פונקציונלי.

פונקציות מחוללות[עריכת קוד מקור | עריכה]

כל פונקציה שבה מוחזר ערך בעזרת המילה yield, נקראת פונקציה מחוללת (Generator Function). קריאה אליה מחזירה אובייקט המשמש כאיטרטור. בקריאה ראשונה לאובייקט מוחזר הערך שמופיע בביטוי yield, ובכל קריאה נוספת הפונקציה ממשיכה מהמקום בו היא הפסיקה. כאשר הפונקציה "חוזרת" (בעזרת return או כשמגיעים לקצה שלה), נזרקת חריגה.

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

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

def fib(n):
    a, b = 0, 1
    for i in range(n):
        a, b = b, a + b
        yield a

על מנת להדפיס את מספרי פיבונאצ'י הראשון עד ה-15 ניתן להשתמש בלולאת for פשוטה:

for i in fib(15):
    print(i)

List Comprehension[עריכת קוד מקור | עריכה]

צורת תחביר זו של השפה (הקשורה לתכנות פונקציונלי) נלקחה משפת Haskell, ומאפשרת ליצור רשימות מורכבות בקלות, בתחביר המזכיר כתיבה פורמלית של קבוצות במתמטיקה (אם כי התוצאה היא רשימה ולא קבוצה).

למשל, בהינתן הגדרת fib לעיל, על מנת לקבל רשימה רגילה של 15 האיברים הראשונים ניתן לכתוב:

[i for i in fib(15)]

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

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

[i**2 for i in fib(15) if i % 2 == 0]

אפשר גם לקנן ביטויים מסוג זה. למשל, הביטוי להלן יוצר את רשימת המספרים הראשוניים הקטנים מ-100:

[i for i in range(2, 100) if all(i % k for k in range(2, i // 2))]

אופרטורים[עריכת קוד מקור | עריכה]

להלן רשימה של האופרטורים בשפה

אופרטור משמעות הערות\דוגמה
+, -, *, **, % חיבור, חיסור\שלילה, כפל, חזקה, שארית
/, // חלוקה ממשית, חלוקת שלמים (עם שארית) 2/4==0.5, 4//2==0.

ההבחנה הזו קיימת רק החל מגרסה 3.0, אם כי ניתן לייבא אותה גם בגרסאות קודמות.

+, * שרשור מחרוזות 'ab'+'cd'=='abcd', ו-'ab'*2=='abab'
+ שרשור tuple-ים (1,2)+(3,4)==(1,2,3,4)
==, =<, =>, <, >, =! שוויון, גדול-שווה, קטן-שווה, גדול מ-, קטן מ-, שונה ניתן לשרשר: x <= 10 ‏ > 0 נכון אם x הוא מספר בין 1 ל-10
[ ] גישה לאינדקס באובייקט הניתן לאיטרציה. 0 הוא האיבר הראשון.
אינדקס שלילי מתייחס למרחק מהאיבר האחרון.
עבור אובייקטים סדרתיים ניתן לגשת גם לקטעים מהסדרה בעזרת ':'.

'abc'[1] == 'b'
range(10)[-1] == 9
'Do you sleep'[3:6] == 'you'

<<, >>, |, &, ^, ~ פעולות לוגיות: הזזה של ביטים ימינה ושמאלה, או, וגם (לוגיקה), XOR, משלים עבור מספרים שלמים (בייצוג משלים ל-2):
1 >> 2 == 4

כל אופרטור מתמטי\לוגי ניתן לשלב יחד עם פעולת השמה, בדומה לשפת C - פעולות כגון x+=5 המוסיפות 5 למשתנה המוצבע על ידי x.

תכנות מונחה-עצמים[עריכת קוד מקור | עריכה]

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

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

ירושה[עריכת קוד מקור | עריכה]

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

שדות ושיטות[עריכת קוד מקור | עריכה]

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

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

class A():
    def __init__(self, name):
        self.name = name 
    def foo(self):
        print("foo is called for " + self.name)
 
a = A("Example")
a.foo()
A.foo(a)

שתי הקריאות ל-A.foo שקולות במקרה זה, וידפיסו את אותה תוצאה: "foo is called for Example".

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

בניה והריסה[עריכת קוד מקור | עריכה]

אין בפייתון שיטה המהווה בנאי (Constructor), אך קיימת בכל מחלקה (באופן מובלע או מפורש) שיטה בשם __init__, המאתחלת את האובייקט לאחר שהוא נוצר. באופן דומה, אין שיטה המשמשת כהורס (Destructor) עבור הריסה של אובייקט, בשל השימוש במנגנון איסוף זבל, אך ישנה שיטה בשם __del__ הנקראת על ידי המנגנון, ומשמשת באופן דומה לזה של השיטה finalize של Java. פייתון תומכת בהעמסת אופרטורים, וכן בירושה מטיפוסים מובנים בשפה, כגון int.

בקרת גישה[עריכת קוד מקור | עריכה]

בניגוד לשפות מונחות-עצמים רבות אחרות, בפייתון אין שום דרך לשלוט על הגישה אל שדות של אובייקט או מחלקה, באופן שיקביל לשדות private למשל, בשפות C++, Java או #C. מעצבי השפה מניחים שאם לא צריך לגשת אל שדה, לא יגשו אליו. על מנת לסמן ששדה או שיטה לא נועדו לגישה מבחוץ מקובל להעניק להם שם המתחיל במקף תחתון בודד "_". שמות המתחילים בזוג מקפים תחתונים "__" עוברים שינוי לאחר יצירת המחלקה, כך שלא ניתן לגשת אליו בקלות מבחוץ, וכן לא ניתן למצוא אותם בעזרת הפקודה dir. למשל, משתנה בשם y__ במחלקה A ייקרא A__y_.

ספרייה סטנדרטית[עריכת קוד מקור | עריכה]

על אף שהשפה עצמה לא מכילה כמות גדולה של כלים, הספרייה הסטנדרטית של פייתון כוללת עשרות מודולים, אשר מקלים מאוד על כתיבת קוד. ישנם לדוגמה מודולים אשר מאפשרים שימוש בפרוטוקולי אינטרנט רבים כגון MIME,‏ HTTP ו-SMTP, שימוש בקידודים ובפורמטי דחיסה שונים כמו למשל base64 ו-zlib, עבודה עם XML-ים ועוד.

שימוש בתעשייה[עריכת קוד מקור | עריכה]

השפה משמשת למספר מטרות. אחד השימושים המקובלים הוא לכתיבת תוכנות שייעודן הוא זמני - לכתוב ולזרוק. מהירות הפיתוח מאפשרת ביצוע משימה כזאת בקלות רבה יותר מאשר שפות מקובלות יותר כמו ‏ ++C, ‏C, Java ‏ואחרות. הרחבה של הרעיון הזה הוא בכתיבת POC - Proof of Concept. כאשר עולה דרישה לתוכנה מסוג חדש, ויש צורך להוכיח שהרעיון ישים באופן עקרוני, אפשר לפתח את כל התוכנה במהירות בפייתון. לאחר הוכחת הישימות עוברים לפיתוח בשפות אחרות, המאפשרות לעתים ביצועים יעילים יותר, על פי הצורך.

עם זאת, אין פירוש הדבר שלא נעשה בשפה שימוש לכתיבת תוכנות גדולות. דוגמאות לכך הן Zope וביטורנט. פייתון היא אחת משלוש השפות העיקריות בהן עובדת חברת גוגל. בין השאר, הגרסה הראשונה של הcrawler של מנוע החיפוש גוגל נכתבה בפייתון‏[3], כל מערכת הפיתוח של גוגל (ניהול גרסאות ובניית מהדורות) מתבצעת בטכנולוגיה מבוססת פייתון. בנוסף, באפריל 2008 הזמינה גוגל גולשים לכתוב אפליקציות פייתון ולהתקינן על מערכת שרתיה.‏[4]

ראו גם[עריכת קוד מקור | עריכה]

קישורים חיצוניים[עריכת קוד מקור | עריכה]

הערות שוליים[עריכת קוד מקור | עריכה]

  1. ^ http://www.python.org/psf/
  2. ^ בגרסאות 2.7 ומטה יש להשתמש ב-raw_input במקום input
  3. ^ Stanford BackRub Web Project
  4. ^ Google App Engine: גוגל תארח אפליקציות רשת בשפת פייתון, לינמגזין