פייתון (שפת תכנות)

Python
פרדיגמות	תכנות מונחה עצמים, תכנות מבני, תכנות פונקציונלי
גרסה אחרונה	פייתון 3: גרסה 3.2.2 פייתון 2: גרסה 2.7.2 (פייתון 3: 4 בספטמבר 2011 פייתון 2: 14 בספטמבר 2010)
טיפוסיות	דינמית, Duck Typing, חזקה
מימושים	מפרשים: CPython, IronPython, Jython, Python for S60, PyPy, Unladen Swallow
ניבים	Stackless, RPython
הושפעה על ידי	ABC, ‏ALGOL 68,‏ Perl,‏ Scheme,C,‏ Java, ‏ Haskell,‏ LISP, Icon
השפיעה על	#C‏, Boo‏, Cobra,‏D,‏ Falcon‏, Groovy, Ruby, ‏JavaScript‏
אתר	http://www.python.org
סיומת	py, .pyw, .pyc, .pyo, .pyd.

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

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

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

עיצוב ופיתוח

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

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

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

מאפייני השפה

המפרש

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

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

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

ריבוי פרדיגמות

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

המשמעות התחבירית של ההזחה

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

מאפיינים תחביריים נוספים

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

מערכת הטיפוסים

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

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

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

טיפוסים מובנים בשפה

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

• טיפוס הנתונים int מאכסן מספר שלם. בגרסאות האחרונות של השפה אוחד טיפוס זה אל תוך long (בעבר מספרים מטיפוס 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), שנקרא לעתים "מערך אסוציאטיבי", הוא טיפוס המאפשר מיפוי ממפתחות לערכים. כל מילון כולל קבוצה של זוגות כאלה, וגישה אל איבר על פי המפתח שלו, מחזירה את הערך המתאים. הקבוצה (set) היא אוסף של איברים שונים, המאפשר לבצע פעולות כמו איחוד, חיתוך, הפרש, בדיקת שייכות וכדומה. קבוצה ומילון הם טיפוסים הניתנים לשינוי, אך אין בהם סדר מוגדר. טיפוס נוסף, "FrozenSet", איננו ניתן לשינוי. פעולת הגישה לאיברים ממומשת בעזרת טבלת גיבוב.

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

מבני בקרה

תנאי

כמו בכל שפת תכנות אימפרטיבית (מבוססת פקודות), ישנה אפשרות לביצוע מותנה של פקודות על ידי פקודת 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 ודומותיהן, שבהן יש צורך להבין את סדר העדיפויות של התנאי. מוקש אחר שאיננו קיים בשפה הוא השגיאה הנפוצה לכתוב = בתנאי במקום ==, ובכך לבצע פעולת השמה במקום השוואה. בפייתון פעולת השמה היא פקודה, Statement, ואיננה יכולה להיחשב לביטוי, ולכן איננה יכולה להימצא בתוך תנאי, וקוד כזה לא יעבור הידור.

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

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

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

לולאות

לולאת while

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

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

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)

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

פקודות יציאה

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

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

חריגות

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

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

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

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

פונקציות ותכנות פונקציונלי

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

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

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

פונקציות מחוללות

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

List Comprehension

צורת תחביר זו של השפה (הקשורה לתכנות פונקציונלי) נלקחה משפת Haskell, ומאפשרת ליצור רשימות מורכבות בקלות. נניח לדוגמה שאנו מעוניינים לשים במשתנה m את כל האיברים שנמצאים ברשימה כלשהי, (נגיד [2,3,7,8,19,20]) ועומדים בתנאי כלשהו (למשל זוגיים), ולבצע עליהם פעולה (למשל העלאה שלהם בריבוע). דרך אחת לעשות זאת היא לעבור בלולאה על כל האיברים ברשימה, לבדוק את התנאי, ואם הוא מתקיים להפעיל עליהם את הפונקציה. בפייתון ישנו תחביר פשוט יותר לבצע זאת:

[m = [i**2 for i in [2,3,7,8,19,20] if i%2 == 0

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

אופרטורים

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

אופרטור	משמעות	הערות\דוגמה
+, -, *, **, %	חיבור, חיסור\שלילה, כפל, חזקה, שארית
/, //	חלוקה ממשית, חלוקת שלמים (עם שארית)	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".

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

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. מעצבי השפה מניחים שאם לא צריך לגשת אל שדה, לא יגשו אליו. על מנת לסמן ששדה או שיטה לא נועדו לגישה מבחוץ מקובל להעניק להם שם המתחיל בזוג מקפים תחתונים "__".

ספרייה סטנדרטית

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

שימוש בתעשייה

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

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

קישורים חיצוניים

• התיעוד של פייתון
• אתר עברי ללימוד פייתון (האתר איננו מעודכן לגרסאות העדכניות של השפה)
• Python-IL - אתר קהילת הפייתון הישראלית
• PyDev - סביבת פיתוח משולבת לפייתון עבור eclipse