תוכן עניינים מבוא הורדה והתקנת התוכנה על גבי המחשב שלכם חלק ראשון - יסודות פקודת print מחרוזות - גרשיים (") או גרש (') פעולות מתמטיות בסיסיות סוגי מספרים - integer או float משתנים תנאים – פקודת if ומבנה הבלוק בפייתון שווה (=) ושווה יותר (==) מערכת תנאים - הפקודות if, elif, else תרגיל-מערכת תנאים פקודת while אופרטורים לוגיים – and, or, not, is מחרוזת string תרגיל מחרוזת - string מחרוזת אחת במרווח או על פני כמה שורות |n \t\ רשימה list הוספה והשמטה של איברים ברשימה השימוש בפקודה index לעומת שימוש בפקודה enumerate טופל tuple מילון dictionary תרגיל - מילון סט - set לולאת for פעולת range פעולות מסיימות בלולאות pass, continue, break מודולו % modulo וחילוק רצפה floor division // modulo תרגיל – תוכנית למציאת מספרים ראשוניים בין 0 ל- 100 Floor division פורמט – format חלק שני – מתקדמים לוגיקה בוליאנית boolean פונקציות - functions משתנה שנוצר בפונקציה נשאר בפונקציה פונקציה עם מספר פרמטרים פונקציה עם מספר בלתי מוגדר של פרמטרים - *args פרמטרים מילוליים – kwargs** תרגיל – מספרי פיבונאצ'י תרגיל – פלינדרום פונקציית lambda תוכנית המחזירה פונקציה lambda List comprehension – אינסטנט רשימה תרגיל list comprehension איתור BMI חריג פונקציה רקורסיבית פיבונאצ'י בפונקציה רקורסיבית חישוב עצרת ! בפונקציה רקורסיבית תרגיל – בניית משולש פסקל באמצעות פונקציה רקורסיבית פקודת input – דו שיח עם המשתמש משחק הניחושים מחלקה class פונקציית __init__() במחלקה תרגיל – איקס מיקס דריקס ירושה פונקציה מקשטת - decorator map() filter() – פונקציות מובנות ממעלה גבוהה מודולים – ספריות תוכניות מדף מן המוכן איטראטור - iterator גנרטור generator טיפול בשגיאות – exeptions try except פרויקט- אבני דומינו חלק שלישי – מתקדמים יותר מחלקה ראשונה – עוד מתודות מיוחדות __setitem__ ו- __getitem__ __delitem__ ו- __len__ attributes המתודות __getattr__, __setattr__ , __delattr__ Hashable objects בסיסי מספרים תרגיל מבינארי לעשרוני ניהול קבצים אתגר מספרים ראשוניים הספריה operator ספריה לחיפוש בטקסט - RE ספריית functools עושים חשבון divmod()-log memoization נספח - גישות לבניית מודלים לפתרון בעיות (או סתם פאזלים מפורסמים) מה עושים עם יותר מידי אפשרויות בפייתון שתי גישות לפתרון חידות - ריבוע קסם חידת 8 המלכות פותר קטמינו katamino solver

הרקע של פייתון - שפת התכנות פייתון (python) פותחה על ידי הולנדי בשם Guido van Rossum ונקראה בהומור על שם חבורות הקומיקאים הבריטית מונטי-פייתון, כאשר משמעות המילה פייתון כשלעצמה היא נחש חנק מסוג פיתון, לכן הלוגו של שפת התוכנה הוא שני נחשי פיתון הכרוכים זה בזה ("נחש נשך נחש"). מידע היסטורי מעניין נוסף תמצאו בשפע באינטרנט, אנחנו, ברשותכם, נעבור ללב העניין. הורה וילד- אף אחד לא תמים, מרבית הילדים הצעירים לא יתחילו את העיסוק בשפת תכנות מבלי שמישהו, קודם לכן, יחשוף להם את הקסם שבדבר, ויש הרבה קסם בדבר. יחד עם זאת, התעניינות של ההורה ולאחר מכן עבודה של הורה וילד החל מהחלקים המגניבים יותר, עשויה להוביל להעמקה גוברת הן של ההורה והן של הילד בפייתון ובכלל בעולם התכנות. מה זה נותן ?! – העמקה של התפיסה הלוגית, הבנה כיצד אלגוריתם עובד, שיפור הבנה במתמטיקה ואנגלית, הנאה ותוספת של פעילות משותפת של הורה וילד, וגם נושאים לשוחח עליהם בזמן שעושים ריצה או הליכה במושב. למעמיקים, קיימות אפשרויות להתקדם בפרויקטים כמו מגשימים שהוא פרויקט סייבר לאומי או לעסוק בתחום בצבא וכן להתקדם בתחום של Machin learning, Data science, Deep learning וכל מה שיהיה חשוב ואופנתי בעתיד, אפילו לעסוק בזה לפרנסה. מאיזה גיל של הילד אפשר להתחיל – אם הילד רק נולד, זה מעולה, עד שהוא יגיע לגיל המתאים ההורה כבר יהיה מנוסה, אולי כבר ינהל חברת תוכנה... אבל, אם רוצים לצעוד יחד, אזי הכיתות הגבוהות יותר של בית הספר היסודי (בהתאם ליכולת האישית של הילד) מתאימות להתחלה וכמובן כל גיל מאוחר יותר זה הולך ומשתפר ונהנים (וגם סובלים) יחד וזה מעולה. ההתחלה בכיתות הגבוהות יותר של היסודי נובעת רק מכך שצריך להכיר את האותיות באנגלית ולאט לאט ללמוד גם קצת אנגלית על הדרך, וגם מתמטיקה בסיסית, אבל אם ילדים יודעים אנגלית בסיסית ומגלים גם יכולת טובה בחשבון, אפשר להתחיל מוקדם יותר. ילדים לומדים מהר יותר ממבוגרים ובהמשך אף מגלים יצירתיות והתלהבות. אני התחלתי עם הבן שלי בגיל צעיר, היום בכיתה ט' הוא עובד באופן עצמאי ונהנה רוב הזמן (יש חלקים סיזיפיים באיתור ליקויים (באגים) בתוכנית אבל הסיפוק מפתרון הבעיות – בסופו של דבר - הוא אדיר). שיטת הלימוד – שיטת הלימוד בספר הזה אינה צועדת בדרך המקובלת, משום שהדרך המקובלת משעממת, זה כמו ללמוד אנגלית באמצעות המילון להתחיל באות a ולסיים ב- z לא מכיר מישהו שידע אנגלית באופן הזה (למרות שהוא לא יפספס אף מילה). לכן, אנו קופצים ישר ובלי הרבה הקדמות לחלקים המעניינים, המגניבים והיפים שהתוכנה יודעת לעשות ובהתאם לרמת קושי עולה ורמת הסברים עולה (ההסברים בהתחלה יהיו פשטניים יותר כדי לא להעמיס, בהמשך נחוץ להבין איך התוכנה עובדת על מנת לטפל בתקלות). פייתון, היות שמדובר בשפה שהיא קוד פתוח וכל אחד יכול להוסיף לה כלים וספריות בלי סוף, היא עצומה ולכן, הדילמה המרכזית בספר (שעכשיו הוא אתר אינטרנט) היא מה להכניס פנימה שהוא מספיק יסודי מרכזי מגניב ומעניין ומה להשאיר בחוץ בשלבים הראשונים של הלימוד. בכל מקרה לא ניתן להכניס לספר אחד (או אפילו עשרה) את כל מה שפותח בפייתון, ומפותח תוך כדי שאנחנו קוראים בספר, כולל ספריות חיצוניות, זה פשוט יותר מידי. הפתרון שלנו הוא ללמד את החומר במעגלים, במרכז, הדברים הבסיסיים, המגניבים, שמסייעים בפיתוח חשיבה, בהתחלה ברמה יותר טכנית (בלי להתעמק ובלי לחדד את האופן שבו המחשב פועל מאחורי הקלעים וללא עמידה על המינוחים והדקויות), וככל שמתקדמים למעגלים רחוקים יותר מהמרכז אנו הולכים ומדייקים את מה שלימדנו קודם לכן. ללמד הכל מהתחלה עם ניואנסים בלי סוף, זה פשוט מתיש. באנו ליהנות. חומר ברשת – לא ניתן לתכנת בפייתון מבלי להיעזר ברשת, יש בעיות ותקלות שאם מישהו לא יגיד לך איך פותרים אותן, החקירה תיקח זמן רב מידי, לכן כאשר נתקלים בבעיה או חוסר הבנה של משהו, אין מנוס מלשאול אותנו בפורום בעברית או לחפש באנגלית באתר המעולה ביותר stackoverflow.com אפשר להגיע גם דרך גוגל. היכולת לחפש בתוך הים העצום הזה הולכת ומשתכללת, הספר הזה תפקידו שלא תלכו לאיבוד, ותקבלו את המידע בעברית (עד כמה שניתן) ואת המונחים המקבילים באנגלית כדי שניתן יהיה למצוא ברשת. עברית שפה יפה ושימוש במונחים- אנו מדינה קטנה דוברת עברית, שפה שאני כל כך אוהב שלא לומר מעריץ, ולא בכדי בחרתי לכתוב בעברית. יחד עם זאת, חייבים ללמוד מונחים לועזיים ולהשתמש בהם, אחרת לא ניתן יהיה למצוא חומרים באינטרנט ולהבין אותם כמו שצריך. לפיכך, אני פעמים רבות מצמיד את המונח בלועזית למילה בעברית, בין אם היא קיימת ובין אם היא לא והרגע המצאתי אותה (או שהיא קיימת ואני לא מכיר אותה). כמו כן, יש מילים חדשות בעברית כמו כרוכית (שטרודל @) או מרשתת (אינטרנט) ועוד רבות ויפות שעדיין לא השתרשו דיין, ולכן אני בוחר שלא לקבל את דין האקדמיה לעברית ולא משתמש בהן (אולי רק מזכיר אותן, בכל זאת, זה שלנו). כך למשך התוצאה המתקבלת מהרצת תוכנית על גבי המחשב נקראת פלט, אולם נוח יותר להשתמש במילה תוצאה, גם פלט נשמע לי שנות השבעים גג שמונים, ולכן אשתמש בה במקום במילה פלט. מהצד השני כן נשתמש במילה ההיסטורית הדפסה כדי לתאר את מה שרואים על מסך המחשב לאחר שמריצים את התוכנית (למרות שלא באמת מדפיסים משהו כשחושבים על זה) בין היתר כי הפקודה נקראת print . כמו כן, במחשב כשמריצים תוכנית רואים את כל מה שהמחשב פולט בסוף התוכנית, אני אעשה שימוש בסימן <<< כדי להראות מה התוכנית מדפיסה בעקבות שורה מסויימת ולאו דווקא בסוף, וזאת למטרת הבנה טובה יותר. אם זה מפריע להעתיק תוכנית כמו שהיא ולהריץ במחשב תסמנו סולמית # משמאל לחלקים שאתם רוצים שהתוכנה לא תקרא. קדימה תעבורו לחלק שמסביר איך מתקנים python בחינם.

פייתון קיימת במערכות הפעלה של אפל ולינוקס ולא צריך להתקין אותה באופן מיוחד. לעומת זאת, במערכת ההפעלה של windows דרושה התקנה כפי שיפורט להלן. התוכנה, גם ל- windows, היא תוכנה חינמית וניתנת להורדה באתר הרשמי של פייתון www.python.org, מומלץ להתקין את הגרסה העדכנית ביותר פייתון 3 (בזמן כתיבת שורות אלה יצאה גרסה 3.7.3), ישנה גם גרסה ישנה של פייתון 2 שאומנם יש אודותיה מידע רב באינטרנט אבל התמיכה בה הולכת להסתיים, כך שמי שצופה פני עתיד כדאי שיתקין את הגרסה העדכנית יותר. כמו כן הספר/אתר הזה עוסק בפקודות המתאימות לגרסה 3 אשר עברו שינוי משמעותי ביחס לגרסה 2. אפשר לזהות מהר מאוד תוכנית שכתובה בפייתון 2 למשל משום שפקודת print מופיעה בלי סוגריים עגולים אחריה. בפייתון 3 פקודת ()print מגיעה עם סוגריים שבתוכם כותבים את מה שרוצים להדפיס. תחת לשונית downloads באתר הרשמי של פייתון לוחצים על הגירסה האחרונה, מאתרים את הקובץ שהורדנו ופותחים אותו - וזה נראה כך - מסמנים את גם את התיבה השנייה (מסומנת למעלה בחץ אדום) ומתקנים את התוכנה. ויש לנו את זה. לעיתים נתקלים בבעיות למשל כאשר יש גרסה קודמת על המחשב, או בשל שימוש בגרסת מערכת הפעלה לא זורמת. לא להתייאש לכל התקלות יש מענה ברשת. בנוסף, מומלץ להתקין סביבת עבודה שהופכת את התכנות בפייתון לנוח מאוד או בכלל לנסבל. בסביבת עבודה מקבלים למשל התראה אם שכחנו לסגור סוגריים או כתבנו פקודה עם שגיאה, והיא גם פותחת חלונות עם אפשרויות כאשר מגיעים לזה ומאפשרת בקלות להריץ תוכניות ולראות מה מתקבל. סביבת העבודה שאני ממליץ עליה היא PyCharm של חברת Jetbrains. ניתן להוריד את גרסת community החינמית באתר https://www.jetbrains.com/pycharm תחת לשונית הורדות. יש גם גרסת מקצוענים בתשלום שאינה דרושה לצרכי הספר הזה. יש גם סביבות עבודה אחרות אם מישהו מכיר ונוח לו יותר לעבוד איתן (אף אחד לא משלם לי בשביל ההמלצה ואין לי עניין אישי בחברה מסוימת). אפשר גם בלי סביבת עבודה בכלל, אבל נראה שכתיבת הקוד הרבה פחות נוחה באופן הזה, וסביבות עבודה מתקנות שגיאות כתיב וגם מצביעות על מרבית הטעויות הבסיסיות באופן אוטומטי וחוסכות זמן רב מאוד. מיותר לפרט בספר את הוראות ההתקנה המלאות של התוכנות משום שהדברים יכולים להשתנות בהתאם לחומרה ולתוכנת ההפעלה של המחשב, ויש גם שינויים מעת לעת, וניתן למצוא הוראות התקנה יחסית בקלות ברשת. בשלב זה מיותר להרחיב אודות ההסבר הטכני על אופן הפעולה היחודי של התוכנה באמצעות interpreter ההופך את התוכנה לשפת מכונה המותאמת למחשב רק בשלב הרצת התוכנה, כך שאין צורך מראש לבצע הידור (קומפילציה compilation) כמו בשפות תוכנה אחרות – כלומר אין צורך לבצע פעולה מקדימה של הפיכת קוד המקור שלנו, לקוד אחר בשפה שהמחשב יודע לקרוא ולבצע.

פקודת print התוכנית הראשונה שנכתבת בדרך כלל, באופן מסורתי, בכל שפת תכנות היא הדפסה על המסך של המשפט "Hello World". print ("hello world") >>> hello world עשינו זאת, כתבנו תוכנית ראשונה בפייתון, השתמשנו בפקודה print, הרצנו את התוכנית (אחרי שלמדנו לעשות זאת), וכתוב על המסך hello world. כמו הרבה דברים בפייתון זה מאוד אינטואיטיבי וברור. בהמשך נבין מדוע המשפט hello world מלווה בגרשיים (") משני צידיו, אולם כבר ניתן לראות את המבנה של פקודת print, היא מגיעה בגרסת פייתון 3 החדשה עם סוגריים () ומדפיסה את מה שבתוכם. כדאי לדעת שבגרסאות קודמות היא היתה מתבצעת ללא סוגריים כך שאם מעתיקים תוכנית ממקור ישן באינטרנט, אחד הדברים הראשונים שצריך לשנות הוא תוספת של סוגריים. שאלה אחרת היא מדוע צריך להוסיף גרשיים לפני ואחרי המשפט והתשובה שלנו היא, כדי שהתוכנה תוכל להבחין מתי אנו כותבים רצף של אותיות ומספרים כמשתנים (עליהם נלמד בהמשך) ומתי אנו כותבים רצף של אותיות ומספרים כטקסט (מחרוזת של סימנים המוכרת בשם string). כאשר אנו כותבים אותיות ומספרים שלפניהם ואחריהם יש גרשיים (אפשר גם גרש אחד מכל צד) אנו קוראים לערך הזה string או בעברית מחרוזת, ומבחינת התוכנה מדובר ברצף של סימנים שמציגים אותם כפי שהם כתובים, והם אינם משתנים (נניח x) שמאחוריהם מסתתרים ערכים אחרים. בואו נכתוב עוד כמה תוכניות פשוטות כדי להתחמם. תוכנית פשוטה יותר היא לבקש מהמחשב לחשב ולהדפיס למסך את התוצאה של התרגיל 1+1 print (1+1) >>> 2 פייתון המדמה שפה טבעית יודעת לעשות את זה באופן פשוט בלי הרבה שורות קוד. המספר 1 אינו ערך מסוג string ולכן אנו לא מכניסים את התרגיל בין גרשיים (או גרש אחד). סוג (type) המידע (data) הוא עניין גדול בכל שפת תכנות, למזלנו בפייתון הצליחו להביא את הדברים לרמת פשטות ואוטומציה כזאת שמצריכה ממש מעט מאיתנו.

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

פעולות מתמטיות בסיסיות בפייתון, כאמור, די פשוט לבצע פעולות מתמטיות בסיסיות. למען האמת גם פעולות מתמטיות מורכבות זה די קל לבצע משום שהשפה תומכת בכך לחלוטין - חיבור print (2+3) >>> 5 חיסור print (5-3) >>> 2 כפל print (2*3) >>> 6 חילוק print (6/3) >>> 2 חזקה print (2**3) >>> 8 אנו רואים שכפל מסומן בכוכבית (*) וחילוק בסלש (/) כמו כן סדר פעולות חשבון עובד כרגיל כמו בשיעורי חשבון בבית הספר (כפל וחילוק לפני חיבור וחיסור, קודם מבצעים פעולות בתוך סוגריים וכו'). לגבי פעולת השורש הדבר מעט יותר מורכב אולם בשלב זה נסתפק בכך ששורש ריבועי ניתן לייצג כחזקה של 1/2 כלומר שורש ריבועי של 4 הוא 4 בחזקת 1/2 ולכן - שורש ריבועי print (16**0.5) >>> 4.0 אפשר גם print (16**(1/2)) >>> 4.0

סוגי מספרים - integer או float אפשר לראות שהתוצאה של השורש הריבועי של 16 היא 4.0 ולא סתם 4 וזה קשור לסוג הערך שאנו מקבלים לאחר הוצאת שורש- מספרים שלמים הם ערכים מסוג integer, ומספרים עשרוניים (0.25 למשל) הם ערכים מסוג float. בפייתון גם מספרים שלמים יכולים לקבל ייצוג כמספרים עשרוניים (שהם ערכים מסוג float), למשל 2.0. בפייתון כאשר מבצעים פעולת שורש או חילוק, באופן אוטומטי מתקבל ערך עשרוני מסוג float, גם אם תוצאת החילוק או השורש היא מספר שלם. ולכן אנו מקבלים 4.0 שהוא ערך מסוג float. למדנו עד כה כי ערכים יכולים להיות מסוג string , integer או float - דוגמאות - String integer float "two" 0 3.0 'd"d' 223 0.0 '123' -10 1.234

משתנים כמו בכל תוכנית אנו יכולים לקבוע שרצף מסוים של אותיות ומספרים יהיה משתנה (ולא סתם מחרוזת טקסט). על מנת לסמן אות או רצף סימנים כמשתנה אנו משתמשים בסימן שווה (=). כך למשל אנו יכולים לקבוע כי x=2 וזה אומר שהמחשב יציב ערך מסוג integr שערכו 2 במיקום מסוים במחשב שהכינוי שלו יהיה x. זה באופן פשטני, הבנה עמוקה יותר של שפת התכנות פייתון תלמד אותנו שמשתנים הם מצביעים על ערכים המאוכסנים במקום מסוים על המחשב וזה שונה ממצב שבו המשתנה מכיל בתוכו את הערך. x=2 print (x) >>> 2 לאחר שביצענו את הפעולה הזאת אנו יכולים לבדוק איזה סוג של ערך מוצב ב- x x=2 print (type(x)) >>> המילה int היא קיצור של integer (מספרים שלמים חיוביים שליליים או אפס שלא בייצוג של שבר עשרוני) משתנים יכולים לקבל גם מחרוזת כמו u2. x="u2" print (type(x)) >>> המילה str היא קיצור של string (מחרוזת). אנו יכולים לבצע השמה של משתנים בתוך משתנים אחרים - x=2 y=x z=y print (z) >>> 2 קודם ביצענו השמה של הערך 2 ב – x לאחר מכן ביצענו השמה של x ב- y (היות שב- x היה 2 גם y שווה עכשיו ל- 2) ולבסוף השמה של y ב- z כך שגם z שווה עכשיו ל- 2. כעת נראה מה המשמעות של משתנה המצביע על עצם. סוגריים מרובעים מגדירים אובייקט מסוג רשימה שילמד בהמשך, כאן המטרה היא להבין את רעיון ההצבעה של פייתון - x=[2,3,4] y=x z=y print (z) >>> [2,3,4] x[0]=4 #כך מגיעים לאיבר בתוך רשימה print (z) >>> [4,3,4] אנו רואים למעלה כי כאשר שינינו את המספר הראשון ברשימה x מ- 2 ל- 4, גם z השתנתה משום שהיא מצביעה על האובייקט (רשימה שגם x מצביע עליה) במיקום מסוים בזיכרון של המחשב. מה שמועתק מ- x ל- y הוא רק המצביע (ולא התוכן) וכך גם במעבר מ- y ל- z. ולכן כאשר שינינו את התוכן עליו הצביע x השתנה גם התוכן עליו הצביע z. לעיתים נרצה ש- הערך של z לא יהיה תלוי בשינויים שחלים על x ולכן נרצה ש- z יצביע בנפרד על מיקום חדש בעל ערך זהה – x=[2,3,4] y=x z=list(y[:]) print (z) >>> [2,3,4] x[0]=4 print (z) >>> [2,3,4] במקרה למעלה יצרנו את z כרשימה חדשה באמצעות הפקודה list הכוללת את ערכי הרשימה y מהראשון עד האחרון (את זה מסמנים כך [:] ). כעת z אינה מצביעה על אותו אובייקט כמו שהמשתנה x מצביע עליו. אנו יכולים לבצע השמה של אותו ערך בכמה משתנים שונים ביחד - x=y=z=2 print (x,y,z) >>> 2 2 2 אפשר גם בסיטונות כך – x,y=2,3 print (x) >>> 2 print (y) >>> 3

תנאים – פקודת if ומבנה הבלוק ב-python פקודת if מאפשרת לנו להורות למחשב לבצע פעולה מסוימת רק אם מתקיימים תנאים מסוימים – למשל אם הערך ב – x גדול מ – 2 הדפס את המילה big - x=5 if x>2: print ("big") >>> big נתבונן במבנה של פקודת if – היא מורכבת מהמילה if שלאחריה כותבים את התנאי (x>2) ולאחריו נקודתיים (:), מבנה זה עתיד לחזור על עצמו בפקודות שונות. בשורה מתחת אנו כותבים מה הפעולה שאנו רוצים שהתוכנית תעשה אם התנאי שלנו מתקיים ו- x גדול מ- 2. הפעולה היא להדפיס על המסך את המילה big. את שורת הפעולה אנו רושמים ימינה מהמיקום שבו מתחילה המילה if וזאת כדי שהמחשב ידע שהפעולה (print ("big" שייכת לתנאי המסוים הזה בלבד. להזזת השורות ימינה (על ידי מקש הרווח) קוראים בעברית הזחה ובאנגלית indentation. מבנה של תוכנית הכוללת שורות מוזחות הוא מהותי ומייחד את פייתון והוא במקום סוגריים שיש בשפות תכנות אחרות. כך אנו יודעים לשייך הוראות מסוימות לתנאים מסוימים בלבד ולדעת מתי רצף של תנאים שייך לאותו בלוק (כאשר הם נמצאים אחד מתחת לשני בדיוק, עם אותו מספר רווחים מתחילת השורה). פייתון מייחסת חשיבות רבה למרווחים ואף סופרת אותם, כדי לדעת את סדר הריצה של התוכנה. מקובל ליצור מרווח של ארבעה (ארבע לחיצות על מקש הרווח) או להשתמש ב- TAB של ארבעה מרווחים כסטנדרט כך שאם רוצים בהמשך לדחוף משהו באמצע יהיה יותר קל, גם יותר נוח לקרוא בלי להתבלבל, ותוכנה קריאה היא העיקר. x=5 if x<2: print ("small") if x>2: print ("big") >>> big אנו רואים בתוכנית שהמחשב מציב את המספר 5 במשתנה x. לאחר מכן המחשב בודק את התנאי האם x<2, היות שהתנאי הזה לא התקיים הוא לא הדפיס את המילה small משום שהפעולה הזאת שייכת רק לתנאי הראשון x<2, והמחשב יודע את זה כי הזחנו את השורה ימינה כך שהפעולה הזאת שייכת רק לתנאי הראשון. לאחר מכן המחשב בודק האם מתקיים התנאי השני x>2, והיות שהוא אכן מתקיים, המחשב מדפיס את המילה big.

שווה (=) ושווה יותר (==) בפייתון הסימן שווה (=) שהכרנו בשיעור חשבון בבית הספר אינו מסמל שיוויון של ערכים בשני צדי משוואה, אלא פקודה להציב ערך מסוים בתוך משתנה מסוים (מדויק יותר לומר בפייתון שהסימן = גורם למשתנה מסוים להצביע על ערך מסוים). כדי להשתמש בשווה שהכרנו בבית הספר, אנו צריכים לעשות שימוש בשווה כפול (==), לוקח זמן להתרגל, אבל בסוף מבינים את זה. הכי טוב בדוגמא - x=5 if x<2: print ("small") if x==5: print ("equal") >>> equal כדי לבדוק אם אגף ימין של משוואה (במקרה למעלה 5) שווה לאגף שמאל (במקרה למעלה x) נעשה שימוש בשווה כפול (==) וכדי להציב ערכים במשתנים נשתמש בשווה בודד (=).

מערכת תנאים - הפקודות if, elif, else לעיתים אנו רוצים לייצר מבנה המורכב משרשרת של תנאים שאם אחד מהם מתקיים המחשב מפסיק את תהליך הבדיקה ומבצע את הפעולה ואם אף אחד מהם לא מתקיים, המחשב מבצע פעולה של ברירת מחדל הכתובה מתחת לפקודה else, כלומר פעולה המתבצעת אם לא התקיים אף תנאי מהתנאים באותה שרשרת. x=2 if x<2: print ("small") elif x>2: print ("big") else: print ("equal") >>> equal למעלה אנו רואים שרשרת של שני תנאים, שאם היה מתקיים אחד מהם המחשב היה מפסיק את הבדיקה ומבצע את הפעולה שרשומה מתחת לתנאי שהתקיים. אנו יודעים שמדובר בשרשרת שת תנאים הקשורים זה בזה משום שהם נמצאים אחד מתחת לשני באותו קו (שייכים לאותו בלוק של קוד). היות ששני התנאים לא התקיימו , x אינו קטן מ – 2 ואינו גדול מ- 2 אנו מבקשים להדפיס את ההוראה למקרה שכזה באמצעות הפקודה else. המילה elif היא דרך מקוצרת לרשום else if כלומר לבחון תנאי נוסף. אין מגבלה לכמות ה- elif שניתן לבדוק בשרשרת תנאים – x=2 if x==1: print ("one") elif x==2: print ("two") elif x==3: print ("three") elif x==4: print ("four") else: print ("not 1 or 2 or 3 or 4") >>> two בדוגמא למעלה אנו רואים שהמחשב עוצר לאחר שהוא מוצא שהתנאי השני (elif x==2) מתקיים ומוציא לפועל את ההוראה הכתובה מתחת לתנאי השני ומדפיס את המילה two בלי להמשיך ולבחון את התנאים האחרים גם אם אחד מהם היה נכון. x=2 if x==1: print ("one") elif x==2: print ("two") elif x<3: print ("less than three") elif x==4: print ("four") else: print ("not 1 or 2 or 3 or 4") >>> two בדוגמא למעלה אנו רואים שהמחשב מדפיס two למרות שגם התנאי השלישי x<3 מתקיים ולכאורה היה צריך להדפיס גם less than three, אבל היות שהמחשב במבנה הזה מפסיק לבדוק את התנאים לאחר שמתקיים תנאי אחד (לפי הסדר שבו הם כתובים), הוא לא מגיע לבדוק את התנאי x<3 ולא מדפיס את ההוראה הרשומה מתחת לתנאי הזה. תרגיל-מערכת תנאים – מה תהיה התוצאה אם בשורה הראשונה בתוכנית למעלה x=5 במקום x=2? אפשר גם להתנות תנאים עבור מחרוזות - x="sababa" if x=="sababa": print ("walla") else: print ("basa") >>> walla צריך לזכור שאותיות גדולות וקטנות משנות את המחרוזת "SABABA" אינה אותה מחרוזת כמו "sababa" באנגלית אנו קוראים לזה case sensitive (תלוי רישיות), כלומר ישנה אבחנה בין מחרוזות או משתנים הכתובים בשילובים שונים של אותיות גדולות (רישיות) וקטנות, כל אחד הוא מחרוזת או משתנה נפרד. אנו יכולים לרשום שרשרת של תנאים שהמחשב לא יפסיק לבחון לאחר שהתנאי מתקיים וזאת כאשר אנו לא משתמשים ב elif אלא בפקודת if חדשה - x=0 if x<5: x=10 if x>=10: x=5 if x>4: x="sababa" print (x) >>> sababa התוכנית למעלה מתחילה בהשמת הערך 0 ב- x היא בודקת האם x<5, והיות שזה מתקיים היא מציבה עכשיו 10 ב – x . לאחר מכן היא בודקת האם x גדול או שווה ל- 10, והיות שזה מתקיים היא מציבה עכשיו 5 ב- x ולבסוף היא בודקת האם x גדול מ – 4 והיות שזה מתקיים היא מדפיסה sababa. מערכת של תנאים עם if ו- else ניתן לכתוב גם באופן מקוצר כמו בדוגמא הבאה – david=10 yehonatan=100 if david>5 else 50 print(yehonatan) >>> 100 עוד דרך:________________________________________________________________________________________________ david=10 print("yehonatan" if david>5 else 50) >>> yehonatan אנו רואים למעלה שהרבה יותר קריא לעשות את זה בשורה אחת.

פקודת while בכל שפת תוכנה יש גם את הפקודה while שמשמעותה "כל עוד" או "כל זמן" והיא כבר שייכת לסוג הפקודות המבצעות בדיקות חוזרות של תנאים ונקראות גם לולאות או באנגלית loop. כמו תמיד, הטוב ביותר הוא להתחיל בדוגמא – x=0 while x<3: print (x) x=x+1 >>> 0 1 2 התוכנית למעלה יוצרת לולאה בעלת תנאי, שכל עוד x קטן מ- 3 היא מבצעת שתי פעולות, היא קודם מדפיסה את הערך העדכני של x (0 בהתחלה) ולאחר מכן היא מוסיפה לערך את המספר 1 (מגדילה אותו ב- 1) וחוזרת על הבדיקה האם x עדיין קטן מ- 3, (היות שהוא כבר שווה 1 וזה קטן מ- 3) היא מדפיסה את המספר 1 והופכת את x ל- 2. מבצעת שוב את הבדיקה האם עכשיו x קטן מ- 3, והיות ש- 2 קטן משלוש, היא מדפיסה את המספר 2 ומוסיפה ל – x את המספר 1 כך שהוא שווה עכשיו ל- 3 , בודקת שוב האםx קטן מ-3, והפעם התשובה היא שלילית, וזה הסימן לפקודת while להפסיק את הבדיקות שלה ולסיים את הלולאה. כך שלאחר ש- x שווה ל- 3 היא לא מדפיסה יותר שום דבר. את הפעולה של הוספת ערך מסוים למשתנה ניתן לרשום בפייתון גם בקיצור – במקום לרשום x=x+3 אפשר לרשום x += 3 וזה יבצע את הפעולה של הוספת המספר 3 לערך הקיים של x . ניתן להבין שפקודת while יכולה לרוץ באופן אינסופי - x=5 while x>3: print (x) x +=1 >>> 5 6 7 8 … עד אינסוף היות ש x גדול מ- 3 התוכנית תדפיס את הערך של x ותוסיף לו 1 ותמשיך לבצע את הבדיקה פעם אחר פעם בלי סוף, משום ש-x לא יהיה אף פעם קטן או שווה ל- 3 אלא רק ילך ויגדל ולולאת ה- while תמשיך להדפיס מספרים עד שמישהו או משהו יעצור אותה. לולאות אינסופיות שכאלה, בלי שמגיע תנאי שעוצר אותן, לרוב אינן רצויות בתוכנה משום שהן תוקעות אותה במקום ממנו היא לא מתקדמת או מבזבזת את הזכרון היקר של המחשב. עכשיו נשלב פקודת if עם פקודת while על מנת ליצור מבנים מורכבים ומעניינים יותר – x=0 while x<5: if x==3: print ("three") print (x) x +=1 >>> 0 1 2 three 3 4 בתוכנית למעלה שילבנו בתוך לולאת ה while פקודת if שבודקת האם x שווה ל- 3, ובמידה שכן היא מדפיסה את המילה three וממשיכה הלאה, מדפיסה את הערך של x ומוסיפה 1 לערך שלו, עד ש x כבר לא קטן מ- 5. כדאי לשים לב שהמחשב יודע לשייך את הדפסת המילה three לתנאי if x==3 רק משום שביצענו הזחה ימינה של שורת הקוד מתחת לשורת הפקודה if. אפשר לבקש מהלולאה לעצור לאחר שמצאנו את מה שאנחנו מחפשים, לשם כך נשתמש בפקודה break שמשמעותה המילולית לשבור את הלולאה - x=0 while x<5: if x==3: break print (x) x +=1 >>> 0 1 2 בדוגמא שלמעלה התוכנית אינה ממשיכה לאחר שמתקיים x שווה ל- 3 והמספר 3 לעולם לא יודפס, משום שההוראה להדפיס אותו נמצאת לאחר פקודת break שמסיימת את הלולאה, למרות ש x עדיין קטן מ - 5.

אופרטורים לוגיים – and, or, not, is כמו בשפות תכנות אחרות גם פייתון עושה שימוש במילים מהשפה הטבעית כדי ליצור מבנים לוגיים כאשר and מסמלת וגם, or מסמלת או, is היא כמו שווה (כמעט) ו- not מסמלת לא. x=0 if x==3 or x<10: print ("ok") else: print ("ko") >>> ok בדוגמא למעלה כאשר אנו משתמשים ב- or, מספיק שמתקיים תנאי אחד (מתוך השניים הכתובים משני צדיו של or), כדי שהפקודה להדפיס את המיליה ok תצא לפועל. x=0 if x==3 and x<10: print ("ok") else: print ("ko") >>> ko בדוגמא למעלה כאשר אנו משתמשים ב- and שני התנאים יחד חייבים להתקיים כדי שהפקודה להדפיס את המילה ok תצא לפועל, והיות ש x לא שווה ל- 3 התוכנית תדפיס ko. x=0 if x is not 3: print ("ok") else: print ("ko") >>> ok אנו רואים שאת האופרטור not כותבים כמו בשפה הטבעית (האנגלית) ואפשר גם בכתיב מקוצר כאשר את המילה not מחליף סימן קריאה, ואנו יוצרים ביחד את הביטוי לא שווה (=!). x=0 if x!= 3: print ("ok") else: print ("ko") >>> ok אפשר להשתמש גם במילה is כמו בשפה הטבעית – x=0 if x is 0: print ("zero") else: print ("not zero") >>> zero לגבי המילה is לעיתים נדמה שהיא מחליפה את הסימן שווה (==) אבל למילה הזאת משמעות יותר עמוקה משיוויון מתמטי כך למשל 2.0 שווה ל- 2, אבל 2.0 אינו 2 משום ש 2.0 הוא טיפוס מסוג float ואילו 2 הוא טיפוס מסוג integer לכן, אם אנו רוצים לבדוק שיוויון מתמטי בלבד נשתמש בשווה כפול (==) ולא ב- is.

מחרוזת string בפייתון יש דרכים רבות לסווג מידע, לנהל מידע ולאכסן אותו, כאשר כל אכסניה מאפשרת טיפול שונה במידע (באנגלית אומרים manipulation אבל איכשהו אני לא משתחרר מהקונוטציה השלילית של המילה הזאת- מניפולציה). בתחילה הזכרנו סוג של מידע המסווג כמחרוזת. הדרכים לסווג מידע כמחרוזת הם לשים אותו בין גרש (') או גרשיים(") משני צדיו או להפעיל את הפקודה ( )str על סוג מידע אחר על מנת לסווג אותו כמחרוזת. נראה איך אפשר לטפל במחרוזות לאחר שיצרנו אותן – אפשר להדפיס את האיבר הראשון במחרוזת – האיבר הראשון מתחיל ב- 0 ולא באחד. x="shalom" print(x[0]) >>> s הדבר מלמד אותנו שמחרוזות כוללות index המסמן כל אחד ואחד מהאיברים במחרוזת (בהמשך נלמד להשתמש בפקודה index). אפשר להדפיס טווח בתוך המחרוזת ולמעשה לבצע חיתוך של המחרוזת - x="shalom" print(x[0:4]) >>> shal בתוכנית למעלה אנו רואים שחיתוך הטווח (המיוצג על ידי שני מספרים לפני ואחרי נקודתיים) כולל את האיבר הראשון (0) האות s אבל אינו כולל את האיבר האחרון בטווח המסומן 4 (האות o), כלומר אנו מקבלים באופן הזה ארבעה איברים שהאינדקס שלהם הוא 0,1,2,3 (ולכן התוכנית הדפיסה את המילה shal) עניין זה יחזור על עצמו כאשר נלמד על רשימות, והוא מבלבל מעט, עד שמתרגלים אליו. אנו יכולים להדפיס מחרוזת מהתחלה (איבר 0) ועד האיבר מספר 7 (לא כולל) בקפיצות של 2 וכך זה נראה - x = '12345678' print(x[0:7:2]) >>> 1357 אפשר גם להדפיס את המחרוזת מהתחלה עד הסוף [::], בעתיד נראה שגם לזה יש שימוש כשלעצמו, אבל כאן אנו מדגימים קפיצות של -1 (מינוס 1), מה שאומר שהמחרוזת מודפסת מהסוף להתחלה. משום ש- index של מינוס 1 מייצג את האיבר האחרון, כמו שמינוס 2 מייצג את האיבר הלפני אחרון. כך זה נראה - x="shalom" print(x[::-1]) >>> molahs אפשר לחבר שתי מחרוזת – x="shalom" y="halechem" print(x+y) >>> shalomhalechem תוכנית שנייה x="shalom" y="halechem" print(x+" "+y) >>> shalom halechem בתוכנית הראשונה חיברנו שתי מחרוזות ובשנייה חיברנו שלוש מחרוזות, כאשר המחרוזת האמצעית היא פשוט מרווח" " -. אפשר להפוך אותיות באנגלית לאותיות גדולות או קטנות – זה מאוד שימושי - x = 'hello' x = x.upper() print(x) x = x.lower() print(x) >>> HELLO hello אפשר לספור כמה פעמים מופיע איבר מסוים במחרוזת – נגיד כמה פעמים האות l מופיעה במילה hello - x = 'hello' print(x.count('l')) >>> 2 אפשר למדוד את אורך המחרוזת - x = 'hello' print(len(x)) >>> 5 אפשר להחליף במחרוזת איבר מסויים באיבר אחר – כך למשל האות l במחרוזת תהפוך ל- t - x = 'hello' x = x.replace('l', 't') print(x) >>> hetto אפשר למצוא מיקום של איבר (index) בתוך מחרוזת (אם מופיע כמה פעמים זה נותן רק את המיקום של האיבר הראשון) - x = 'shalom' print(x.index('a')) >>> 2 החסרון הוא שאם מה שמחפשים לא נמצא במחרוזת מקבלים הודעת שגיאה. על מנת להימנע משגיאה אפשר להשתמש גם ב- (('print(x.find('h כך, במקרה שמה שמחפשים לא נמצא במחרוזת, מקבלים את ה ערך -1(מינוס 1) ולא הודעת שגיאה. יש דרך מקוצרת להכפיל מופע של מחרוזת – פשוט כותבים את זה כתרגיל כפל - x = 't' x = x*3 print(x) >>> ttt

תרגיל מחרוזת (string) - א. הפכו את המספר 123456789 למחרוזת בתוך המשתנה x. ב. כתבו תוכנית שתדפיס מתוך המחרוזת את המספרים 123 שלאחריהם 789 כך שתתקבל המחרוזת "123789" הדרך הפשוטה לפתרון התרגיל - x=str(123456789) print(x[0:4]+x[6::]) >>> 1234789 כדאי לשים לב ש- [::6] פירושו החל מהאיבר מספר 6 שהוא הספרה 7 היות שמתחילים את האינדקס מ- 0. ודאבל נקודתיים פירושן, עד הסוף.