ויקיפדיה

פייתון – הבדלי גרסאות

עיון אינטראקטיבי בהיסטוריה
→ העריכה הקודמתהעריכה הבאה ←
תוכן שנמחק תוכן שנוסף
חזותיקוד ויקי
אין תקציר עריכה
תגיות: עריכה ממכשיר נייד עריכה מיישום נייד עריכה מאפליקציית iOS קישורים לדפי פירושונים
הסרת קישורים עודפים
שורה 8:
| מתכנן = [[גואידו ואן רוסום|גואידוֹ ואן רוֹסוּם]]{{הערה|[http://he.forvo.com/word/guido_van_rossum/ הגייה] באתר [[Forvo]]}}
| מפתח = קרן התוכנה של פייתון{{הערה|[http://www.python.org/psf/ Python Software Foundation (PSF)], באתר פייתון}}
| גרסה אחרונה = 3.9.0 ב־[[5 באוקטובר]] [[2020]] {{ש}} 2.7.18 ב־[[20 באפריל]] [[2020]]
| תאריך גרסה אחרונה =
| טיפוסיות = דינמית ([[טיפוסיות ברווז]]), חזקה, מובלעת
| מימושים = [[מפרש (תוכנה)|מפרשים]]: CPython, [[IronPython]], Jython, Numba, PyPy, MicroPython
שורה 20:
'''פייתון''' (ב[[אנגלית]]: '''Python''') היא [[שפת תכנות דינמית]] מהנפוצות ביותר. פייתון תוכננה תוך שימת דגש על קריאוּת הקוד, וכוללת מבנים המיועדים לאפשר ביטוי של תוכניות מורכבות בדרך קצרה וברורה. אחד המאפיינים הבולטים בתחביר השפה הוא השימוש ב[[הזחה]] להגדרת בלוקים של קוד (ללא שימוש בסוגריים או ב[[מילה שמורה|מילים שמורות]] לצורך כך, כמו ברוב השפות הנפוצות).
 
פייתון היא שפה מרובת־[[פרדיגמת תכנות|פרדיגמות]], המאפשרת [[תכנות מונחה-עצמים|תכנות מונחה־עצמים]], [[תכנות פרוצדורלי]], ובמידה מסוימת גם [[תכנות פונקציונלי]]. לשפה [[ספרייה (תכנות)|ספרייה]] סטנדרטית גדולה וענפה, והיא תומכת באופן מובנה בהרחבה שלה אל שפות אחרות (בתלות במפרש: [[שפת C|C]]{{כ}}, [[C++|++C]],{{כ}} [[Java]]{{כ}} ו־[[C Sharp|#C]]).
 
לשפה שתי גרסאות ראשיות, פייתון 2 ופייתון 3. פייתון 2 איננה בפיתוח יותר (למעט תיקון באגים), והתמיכה בה הסתיימה ב-2020ב־2020{{הערה|[http://legacy.python.org/dev/peps/pep-0373/#update the development and release schedule for Python 2.7.]}}.
 
שם השפה "פייתון" נבחר כ[[מחווה (אמנות)|מחווה]] לקבוצה הקומית "[[מונטי פייתון]]"{{הערה|{{קישור כללי|כתובת=https://docs.python.org/3/tutorial/appetite.html|כותרת=Whetting Your Appetite|אתר=python.org}}}}.
שורה 34:
בין הכללים על פיהם מתוכננת השפה:
* "צריכה להיות דרך אחת, ועדיף אחת בלבד, לבצע זאת" (כתגובה לתפיסה של התכנות בשפת [[פרל]]: "יש יותר מדרך אחת לבצע זאת").
* "כולנו אנשים בוגרים כאן" -– כלומר, אפשר לסמוך על מתכנת המשתמש בקוד קיים שלא יבצע בו דברים שברור שלא התכוונו אליהם מלכתחילה (כנימוק, בין היתר, כנימוק לשאלה מדוע השפה תומכת ב[[כימוס]] פחות משפות מונחות־עצמים אחרות).
 
==מאפייני השפה==
===המימוש: מהדר ומפרש===
תוכניות פייתון נכתבות בקובצי טקסט, שעל-פישעל־פי [[קונבנציה]] נשמרים במערכת ההפעלה בסיומת py. תוכניות פייתון עשויות לכלול קבצים רבים.
 
על מנת להריץ קוד פייתון יש לבחור מימוש -– מהדר או מפרש -– שיתרגם את הטקסט של התוכנית לפקודות שיתבצעו במעבד. לפייתון קיים "מימוש-ייחוסמימוש־ייחוס" כלומר מערכת שהיא זו שמגדירה את ההתנהגות של קוד שנכתב בשפה -– בשם CPython. מימוש-הייחוסהמימוש־ייחוס פועל בשני שלבים נפרדים: שלבהידור ההידור ושלב ההרצהוהרצה.
 
# בשלב הראשון, קוד פייתון מהודר לשפת ביניים נמוכה, מבוססת מחסנית ([[Bytecode]]). תוצאת ההידור הזה נשמרת בקבצים עם הסיומת pyc.
שורה 56:
פייתון היא שפה שתומכת בשימוש במספר [[פרדיגמת תכנות|פרדיגמות תכנות]] שונות. ניתן לכתוב קוד [[תכנות מונחה עצמים|מונחה עצמים]], [[תכנות פרוצדורלי|פרוצדורלי]] ובמידה מסוימת [[תכנות פונקציונלי]]. [[תכנות גנרי]] נתמך בשפה באופן טריוויאלי, בדומה לכל שפה בעלת [[טיפוסיות]] דינמית.
 
פייתון מאפשרת ואף מעודדת התבוננות־פנימה ([[Reflection (תכנות)|Reflection]]), ותומכת ב[[עיבוד מקבילי#תכנות מקבילי|תכנות מקבילי]] ו[[תכנות מוכוון-אירועים|תכנות מוכוון־אירועים]] באמצעות מודולים מתאימים בספרייה הסטנדרטית.
 
===ניהול הזיכרון ויצירת אובייקטים===
פינוי הזיכרון מבוצע בצורה אוטומטית, על ידי מנגנון [[איסוף זבל (מדעי המחשב)|איסוף זבל]], בעיקר תוך שימוש במניית התייחסויות, ולא דורש התייחסות מפורשת מצד המתכנת.
 
[[אובייקט (מדעי המחשב)|אובייקט]]ים מוקצים על גבי הערימה, כאשר הם נוצרים על ידי קריאה למחלקה, למשל <tt> (x=str(15 </tt>{{כ}}, או על ידי הצבה של ליטרלים בשפה -– הכוללים מספרים, מחרוזות, רשימות, מילונים, פונקציות [[תחשיב למדא|למבדה]], או על ידי קריאה לפונקציה שיוצרת אותם. שני מנגנונים נוספים הם List Comprehension ו־Generators, שיתוארו בהמשך.
 
המשתנים עצמם, "הרפרנסים", הם [[מחרוזת (מדעי המחשב)|מחרוזות]] פשוטות המשמשות כמפתחות במילון שמגדיר את תחום ההכרה (scope) הנוכחי.
 
===המשמעות התחבירית של ההזחה===
בשפות רבות אין משמעות תכנותית להזחה כשלעצמה: כל בלוק מוקף בתווי בקרה מיוחדים המסמנים את תחילתו וסופו של הבלוק, אף ללא כל הזחה (סוגריים מסולסלים ב־[[C (שפת תכנות)|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. עם זאת, ניתן לגשת אל כל תו במחרוזת באמצעות גישה לפי אינדקס, כמו בטיפוסים הסדרתיים, וניתן להמיר ביניהם בקלות. ניתן לכתוב מחרוזות הן בעזרת גרשיים כפולים: "hello" והן בעזרת גרש יחיד: 'hello'. אין כל הבדל בין צורות אלו, אך מקובל להשתמש בגרש יחיד. מחרוזות הנכתבות בין שלושה גרשיים רצופים -– """hello""" או {{ללא קוד ויקי|'''hello'''}} -– ניתן לפרוש על פני מספר שורות ברצף. החל מגרסה 3, המחרוזות הן [[Unicode]], אם כי ישנו טיפוס bytes עבור רצפים של בתים. בגרסה 2 המצב הפוך -– המחרוזות הבסיסיות הן בתקן [[ASCII]], וישנו טיפוס מיוחד עבור מחרוזות Unicode.
 
אובייקטים מטיפוסי מספרים ומחרוזות הם בלתי ניתנים לשינוי (Immutable), כלומר שינוי ערכו של משתנה מטיפוס כזה הוא בעצם הסרת ההתייחסות אליו והפנייתה לערך חדש.
 
בשפה מוגדרים שני טיפוסים סדרתיים: tuple ו־list.
* הטיפוס tuple הוא ייצוג ממוחשב של [[N-יה סדורה|N־יה סדורה]]: רצף קבוע של ערכים מטיפוסים אחרים (כלשהם), המיוצג על פי רוב בתוך סוגריים. לדוגמה (1, 2, 3). טיפוס זה מקל על דימוי של החזרת מספר ערכים מפונקציה בודדת, או ביצוע פעולת החלפה בין משתנים (כך ניתן להחליף בין המשתנים a, b באמצעות הפקודה "a, b = b, a"). גם אובייקט מטיפוס זה איננו ניתן לשינוי, דבר המאפשר שימוש בו כמפתח עבור מילון (ראה בהמשך), בשל היכולת להשתמש בו ב[[טבלת גיבוב]]. (למעשה, בשל העובדה שפייתון היא בעלת טיפוסיות דינמית, ובשל השימוש בסמנטיקת רפרנס, זהו מערך לכל דבר).
* המקבילה ל[[מערך (מבנה נתונים)|מערך]] בפייתון הוא מבנה הנתונים "רשימה" (list). זהו שם מטעה במקצת; על אף שמו, טיפוס זה הוא למעשה מערך שגודלו משתנה, באופן שקוף למתכנת, וניתן לגשת אל כל איבר בו על ידי אינדקס. רשימה תוגדר בין סוגריים מרובעים, לדוגמה ['x','y','z']. בניגוד ל־tuple, שתוכנו אינו ניתן לשינוי, ברשימה ניתן לשנות כל אחד מהאיברים, וכן להרחיב אותה או להסיר ממנה איברים. בשל כך, לא ניתן להשתמש ברשימות כמפתחות למילון. בשביל אופציות אחרות של מערך שאינן אפשריות ברשימה, ניתן לייבא מודול מתאים.
* ה[[מילון (מבנה נתונים)|מילון]] (dict), הנקרא לעיתים "מערך אסוציאטיבי" או "hash", הוא טיפוס המאפשר מיפוי ממפתחות לערכים. כל מילון כולל קבוצה של זוגות כאלה, וגישה אל איבר על פי המפתח שלו מחזירה את הערך המתאים.
שורה 100:
החל מהגרסאות האחרונות של השפה אוחדו המחלקות והטיפוסים, וכולם שייכים למטא־מחלקה "type" (כולל המחלקה type עצמה).
 
=== אנוטציות ובדיקת- טיפוסים סטטית ===
כאמור, פייתון היא שפה דינמית ולא מתבצעת בדיקת טיפוסים בזמן הידור. עם זאת, פייתון מאפשרת להוסיף אנוטציות -– ביטויים שאין להם כל התנהגות בזמן ריצה -– לפרמטרים של פונקציה ואף למשתנים, וישנה בשפה ספרייה בשם typing המאפשרת לבטא טיפוסים רבים. שילוב זה מאפשר לכתוב בשפה תוכניות אותן ניתן לבדוק על ידי כלים חיצוניים לבדיקת- טיפוסים{{הערה|[http://www.mypy-lang.org/ מערכת mypy לבדיקת טיפוסים בפייתון]}}, וכך לאתר שגיאות טרם ההרצה.
 
להלן דוגמה לקוד פייתון עם סימון טיפוסים (הסימון <- הוא עבור טיפוס ההחזרה. טיפוסי משתנים מסומנים בעזרת הערות):
שורה 118:
 
===תנאי===
כמו בכל שפת תכנות אימפרטיבית (מבוססת פקודות), ישנה אפשרות לביצוע מותנה של פקודות על ידי [[פקודת if]], בה מחושב ערכו של [[ביטוי (מדעי המחשב)|ביטוי]] מסוים ומתבצע רצף פקודות אם ערך זה הוא "אמיתי", אחרת מתבצע רצף פקודות המפורט לאחר המילה "else", אם קיים כזה. אין בפייתון מבנה switch כמו בשפות אחרות, אך ניתן להשתמש במילה elif המהווה קיצור עבור else if. ערך "אמיתי" איננו רק הערך True של הטיפוס bool, אלא כל ערך שהמחלקה שלו מגדירה אותו כאמיתי -– למשל מספרים השונים מ־0, רשימות לא ריקות, מחרוזות לא ריקות, וכדומה.
 
דוגמה לתחביר של [[פקודת תנאי]], הבודקת אם משתנה x הוא זוגי על ידי בדיקת שארית בחלוקה ל־2, ומדפיסה הודעה מתאימה:
שורה 128:
</syntaxhighlight>
 
בפקודה זו ניתן לראות את היתרון הגדול שמעניקה ההזחה: לא תיתכן תופעה של else "מידלדל" -– כל else קשור בדיוק לפקודת ה־if הרשומה הישר מעליו. זאת בניגוד לשפות כמו C, C++, Java ודומותיהן, שבהן יש צורך להבין את סדר העדיפויות של התנאי. מוקש אחר שאיננו קיים בשפה הוא השגיאה הנפוצה לכתוב = בתנאי במקום ==, ובכך לבצע פעולת השמה במקום השוואה. בפייתון פעולת השמה היא [[פקודה (מחשב)|פקודה]], Expression, ואיננה יכולה להיחשב ל[[ביטוי (מדעי המחשב)|ביטוי]], Statement, ולכן איננה יכולה להימצא בתוך תנאי, וקוד כזה לא יעבור הידור.
 
פייתון לא תומכת בבורר מרובה כניסות (בדומה ל־switch בשפת C ודומותיה), אך קיימת מילה שמורה elif המאפשרת לבדוק רצף של תנאים, באופן דומה למנגנון זה:
שורה 141:
print("I don't know what x is")
</syntaxhighlight>
ללא המילה elif היה צורך לבצע קינון עמוק במקרה זה -– טכניקה מאוד לא נוחה באופן כללי, ובפרט בפייתון שבה כל קינון נוסף מגדיל את ההזחה:
<syntaxhighlight lang="python">
if x % 2 == 0:
שורה 154:
print("I don't know what x is")
</syntaxhighlight>
בניגוד לשפות רבות אחרות, לפקודה else שימושים בהקשרים אחרים -– לולאות וניהול חריגות.
 
====ביטוי תנאי====
שורה 190:
 
==== לולאת for ====
מבנה נוסף ועיקרי בשפה הוא '''לולאת for'''. בלולאה זו מוגדר משתנה, ומתקבלת רשימה (או כל טיפוס שניתן לעבור עליו לפי סדר -– "Iterable"). המשתנה מקבל בכל מחזור את ערכו של איבר אחר ברשימה, שוב ושוב עד שמגיעים לסוף הרשימה. מבנה זה אינו דומה ללולאת for בשפות ממשפחת ה־C, ומזכיר מעט את לולאת foreach בשפות אחרות. על מנת לבצע פקודה מספר פעמים מוגדר משתמשים בפונקציה (range(x המחזירה [[איטרטור]] העובר על המשתנים בין 0 ל־x (בגרסאות קודמות של השפה החזירה פקודה זו רשימה מתאימה).
 
דוגמה לשימוש בלולאת for להדפסת ריבועי המספרים בין 0 ל־5, לא כולל 5:
שורה 222:
</syntaxhighlight>
 
בפייתון כל שגיאה מעלה (raise) חריגה, וכל שגיאה ניתן ללכוד -– [[חלוקה באפס]], שגיאות קלט־פלט, שמות שטרם הוגדרו בקוד, וכו' -– למעט שגיאות תחביר. החל מגרסה 3.0, שגיאות המוגדרות על ידי המשתמש צריכות להיות מחלקות היורשות מהמחלקה BaseException -– לא ניתן לבצע פעולה כגון "raise "error, כיוון שהמחרוזת "error" היא מטיפוס str שאיננה יורשת מ־BaseException.
 
===מנהלי הקשר וניהול משאבים===
שורה 238:
הפונקציות והשיטות בשפה הן אובייקטים לכל דבר. ישנם 7 סוגים של עצמים ברי־קריאה (callable) בפייתון:
* פונקציות מובנות ושיטות מובנות. אלה נכתבו בשפת האם של המפרש והוטמעו אל תוך השפה.
* פונקציות המוגדרות על ידי המשתמש, נכתבות באמצעות שימוש במילה השמורה def (קיצור של define -– להגדיר).
* שיטות המוגדרות על ידי המשתמש, נכתבות בדומה לפונקציות, אך מוגדרות בתוך מחלקה. כל השיטות בפייתון הן סטטיות, אך כאשר קוראים לשיטה מתוך אובייקט, בצורה ()x.foo, האובייקט מועבר בתור הארגומנט הראשון. (מקובל לקרוא לו self, המקביל ל־this בשפות ממשפחת ++C, אך זו איננה מילת מפתח ולא מילה שמורה).
* ביטויי למדא -– פונקציה אנונימיות בת שורה אחת, המוגדרת תוך שימוש במילה השמורה lambda.
* מחלקות -– כל מחלקה בפייתון היא אובייקט מהטיפוס type, וקריאה אליה באמצעות אופרטור הקריאה לפונקציה () יוצר אובייקט מהטיפוס שלה.
* כל אובייקט שהוגדרה עבורו השיטה __call__, הוא אובייקט בר־קריאה (פעולה זו מקבילה להעמסה של אופרטור () בשפת ++C).
 
=== פונקציות מוגדרות על ידי המשתמש ===
[[קובץ:Fibonnacci-Python.png|שמאל|ממוזער|350px|מימוש של פונקציית [[סדרת פיבונאצ'י|פיבונאצ'י]] במפרש אינטראקטיבי של פייתון, המזהים צבועים לפי תפקידיהם -– [[משתנה (תכנות)|משתנים]], [[אופרטור (תכנות)|אופרטורים]] ומילים שמורות. ניתן להבחין בשימוש בהזחה וב־tuple, אם כי ללא הסוגריים. את התוצאה לא ניתן לאחסן באף טיפוס פרימיטיבי בשפות ממשפחת ה־C.]]
בדומה למרבית שפות התכנות הפרוצדורליות, ניתן להגדיר בפייתון פונקציה -– מבנה סינטקטי המגדיר חישוב ומחזיר ערך. בשל היותה שפה בעלת טיפוסיות דינמית, פונקציות בפייתון אינן מגדירות את טיפוס ההחזרה שלהן, ואינן מגדירות את טיפוסי הארגומנטים. פונקציה מוגדרת באמצעות המילה השמורה def, אחריה שם הפונקציה, ואחריו רשימה של 0 או יותר שמות של פרמטרים פורמליים (ארגומנטים) בתוך סוגריים. לאחר אלה מופיע '''גוף הפונקציה''' -– בלוק המגדיר את החישוב אותו היא מבצעת. כמו כל בלוק בשפת פייתון, הוא מתחיל בנקודתיים וממשיך עד לשורת הקוד הראשונה שאיננה מוזחת עוד.
 
פונקציה מסיימת את החישוב שבה ומחזירה ערך באחת משתי דרכים: או על ידי המילה השמורה return או על ידי הגעה לסוף הבלוק המגדיר אותה. במקרה האחרון, או כאשר פקודת return מופיעה ללא ביטוי אחריה, מוחזר מהפונקציה הערך None מהטיפוס NoneType. פונקציה עשויה להסתיים גם על ידי זריקת חריגה, אך במקרה כזה היא איננה מחזירה ערך.
שורה 362:
</div>
|-
| {{ללא קוד ויקי|<<, >>, {{!}}, &, ^, ~}} || פעולות לוגיות: הזזה של ביטים ימינה ושמאלה, [[או (לוגיקה)|או]], [[וגם (לוגיקה)]], [[XOR]], [[לא (לוגיקה)|משלים]] || עבור מספרים שלמים (בייצוג [[משלים ל-2|משלים ל־2]]):{{ש}}1 >> 2 == 4
|-
| @ || [[כפל מטריצות|הכפלת מטריצות]] || החל מגרסה 3.5. הסימן משמש גם לשימוש בדקורטורים
שורה 368:
|}
 
כל אופרטור מתמטי/לוגי ניתן לשלב יחד עם פעולת השמה, בדומה לשפת C -– פעולות כגון x+=5 המוסיפות 5 למשתנה המוצבע על ידי x.
 
== תכנות מונחה־עצמים ==
השפה תומכת ב[[תכנות מונחה-עצמים|תכנות מונחה־-עצמים]], אך איננה כופה את המתכנת להשתמש בו. כך ניתן לכתוב תוכניות קצרות ופשוטות, וגם מערכות תוכנה מורכבות.
 
כל ישות בשפה היא אובייקט, ובפרט כל מחלקה היא בעצם אובייקט של המחלקה type. ישנה אפשרות להורשה מרובה, וכל מחלקה יורשת ישירות או בעקיפין מן המחלקה object.
שורה 401:
 
===שדות ושיטות===
השפה מאפשרת הגדרת שדות נתונים -– משתנים -– השייכים למחלקה (משתני מחלקה, נקראים גם משתנים סטטיים) או לאובייקט (משתני מופע). ניתן לגשת לשדות באופן ישיר, ואין דרך להגדיר "תכונות" -– שדות שהגישה אליהם מבוקרת באמצעות מתודות -– כמו בשפת [[Ruby]].
 
שיטות שייכות באופן בלעדי למחלקה, כלומר הן תמיד סטטיות. בהצהרה של שיטה, אם מתבצעת קריאה לשיטה דרך אובייקט ספציפי, הוא מועבר בתור הפרמטר הראשון של השיטה (שמקובל לקרוא לו self), באופן מובלע. ניתן לבצע קריאה כזאת גם באופן מפורש:
שורה 418:
שתי הקריאות ל־A.foo שקולות במקרה זה, וידפיסו את אותה תוצאה: "foo is called for Example".
 
בניגוד לשפות מונחות־עצמים אחרות, ניתן להוסיף לכל אובייקט (ומחלקה, שגם היא אובייקט) שדות נתונים בכל זמן נתון, גם לאחר סיום הגדרת המחלקה, כלומר גם בזמן ריצה, או באופן מותנה. למעשה, כל האמור הוא התעסקות עם מרחב השם (namespace) בלבד -– כלומר, בכל יצירה של אובייקט, מכל טיפוס, נוצר מרחב־שם, ואליו ניתן לשייך אובייקטים אחרים בכל זמן נתון (במגבלות כלשהן. וכל זה נכון גם לגבי מודולים).
 
===בניה והריסה===
שורה 436:
* NumPy – חבילת הרחבה [[מתמטיקה|מתמטית]] הכוללת [[פונקציה|פונקציות מתמטיות]] רבות, [[וקטור (אלגברה)|וקטור]]ים ו[[כפל מטריצות]], [[אלגברה ליניארית]], [[טרנספורם פורייה]] ועוד.
* SciPy – חבילת הרחבה ל[[מדעים מדויקים]].
* MatPlotLib – חבילת הרחבה המאפשרת יצירת [[תרשים|תרשימים]] ו[[גרף (נתונים)|גרפים]] בדומה ל-ל־[[MATLAB]].
 
כדי להשתמש בחבילות אלו יש להתקינן (באמצעות הפקודה PIP install בצירוף שם החבילה או באמצעות python -m pip install test בזמן שtest מסמל את שם החבילה) ואז להוסיף בראש קובץ הקוד את השורות הבאות:
שורה 446:
 
==שימוש בתעשייה==
השפה משמשת למספר מטרות. אחד השימושים המקובלים הוא לכתיבת תוכנות שייעודן הוא זמני -– לכתוב ולזרוק. מהירות הפיתוח מאפשרת ביצוע משימה כזאת בקלות רבה יותר מאשר שפות מקובלות יותר כמו {{כ}} ++C, {{כ}}C, Java {{כ}}ואחרות. הרחבה של הרעיון הזה הוא בכתיבת POC -– Proof of Concept. כאשר עולה דרישה לתוכנה מסוג חדש, ויש צורך להוכיח שהרעיון ישים באופן עקרוני, אפשר לפתח את כל התוכנה במהירות בפייתון. לאחר הוכחת הישימות עוברים לפיתוח בשפות אחרות, המאפשרות לעיתים ביצועים יעילים יותר, על פי הצורך. עם זאת, אין פירוש הדבר שלא נעשה בשפה שימוש לכתיבת תוכנות גדולות. דוגמאות לכך הן [[Zope]] ו[[ביטורנט]].
 
שימוש נוסף בפייתון הוא לפיתוח [[אלגוריתם|אלגוריתמים]] בתחומי [[מדעים מדויקים|המדעים המדויקים]] וה[[הנדסה]], בדומה לשימוש ב-ב־[[MATLAB]]. חבילות ההרחבה, כגון NumPy, המאפשרות עבודה יעילה עם [[וקטור (אלגברה)|וקטורים]] ו[[מטריצה|מטריצות]], הופכות אותה לנוחה ושימושית למטרה זו.
 
פייתון היא אחת משלוש השפות העיקריות בהן עובדת [[גוגל (חברה)|חברת גוגל]]. בין השאר, הגרסה הראשונה של [[זחלן רשת|זחלן הרשת]] של [[גוגל (מנוע חיפוש)|מנוע החיפוש גוגל]] נכתבה בפייתון{{הערה|1=[http://web.archive.org/web/19971210065425/backrub.stanford.edu/backrub.html Stanford BackRub Web Project]{{כותרת קישור נוצרה על ידי בוט}}}}, כל מערכת הפיתוח של גוגל (ניהול גרסאות ובניית מהדורות) מתבצעת בטכנולוגיה מבוססת פייתון וחלק מאתריה הגדולים כגון [[יוטיוב]] כתובים בצורה כמעט גורפת בפייתון. בנוסף, באפריל [[2008]] הזמינה גוגל גולשים לכתוב אפליקציות פייתון ולהתקינן על מערכת שרתיה{{הערה|1=[http://linmagazine.co.il/enterprise/2008/04/08/google-app-engine Google App Engine: גוגל תארח אפליקציות רשת בשפת פייתון], לינמגזין<!-- Bot generated title -->}}.
 
[[אנקונדה (מנהל חבילות תוכנה)|אנקונדה]] היא הפצה של שפות התכנות פייתון לתכנות מדעי ([[מדע הנתונים|מדעי הנתונים]], יישומי [[למידת מכונה]], עיבוד נתונים בקנה מידה גדול, ניתוח ניבויי וכו').
 
עוד שימושים נוספים בפייתון הם : [[פיתוח אפליקציות]], [[כריית מידע]], [[בינה מלאכותית]], [[מחשוב בענן]], [[בניית אתרים]], [[Big data|דאטה]]. ועוד כל מיני דברים {{דרוש מקור}}.
 
==ראו גם==
שורה 467 ⟵ 468:
* [https://data.cyber.org.il/python/python_book.pdf מדריך מלא לשפת פייתון באתר של מטה הסייבר הצה"לי]
* [http://vlib.eitan.ac.il/python אתר עברי ללימוד פייתון] (האתר איננו מעודכן לגרסאות העדכניות של השפה)
* [http://www.python.org.il/ Python-IL] -– אתר קהילת הפייתון הישראלית
* [http://pydev.org PyDev] -– [[סביבת פיתוח משולבת]] לפייתון עבור [[eclipse]]
 
== הערות שוליים ==
אוחזר מתוך "https://he.wikipedia.org/wiki/פייתון"