פייתון

‫רות בורנשטין‬
‫שיעור ‪ :1‬מבוא‪ ,‬משתנים ואופרטורים‬ ‫‪rutbor@edu.hac.ac.il‬‬

https://www.geektime.co.il/python-package-index-3653-libraries/
MOST POPULAR PROGRAMMING LANGUAGES 2020
https://www.itprotoday.c
om/programming-
languages/most-popular-
programming-languages-
what-s-hot-what-s-not-
2022
?‫מי משתמש בפייתון‬
You Tube
Dropbox
Intel
Ebay
Instagram
Google
Amazon
Nasa
And more…
‫מה זה ‪?PYTHON‬‬
‫מטרה חשובה של מפתחי ‪ Python‬היא שהשפה תהיה‬
‫"כיפית" לשימוש‪.‬‬
‫דבר זה בא לידי ביטוי בשם השפה –‬
‫אשר נבחר כמחווה לקבוצה הקומית "מונטי פייתון"‪.‬‬

‫מה זה ‪?PYTHON‬‬
‫פייתון תוכננה תוך שימת דגש על קריאוּת הקוד‪ ,‬וכוללת מבנים המיועדים לאפשר‬
‫ביטוי של תוכניות מורכבות בדרך קצרה וברורה‪.‬‬
‫אחד המאפיינים הבולטים בתחביר השפה הוא השימוש בהזחה להגדרת בלוקים של‬
‫קוד )ללא שימוש בסוגריים או במילים שמורות לצורך כך‪ ,‬כמו ברוב השפות‬
‫הנפוצות(‪.‬‬
‫פייתון היא שפה מרובת־פרדיגמות‪ ,‬המאפשרת תכנות מונחה‪-‬עצמים‪ ,‬תכנות‬
‫פרוצדורלי‪ ,‬ובמידה מסוימת גם תכנות פונקציונלי‪.‬‬

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

‫דוגמא לתוכנית‬
‫)"!‪print("Hello, World‬‬
‫זהו ?‬
‫כן!‬
‫מאפיינים תחביריים‬
‫המבנה של בלוקי קוד בתוכנית נקבע על ידי ההזחה שלהם‪:‬‬ ‫‪‬‬

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

‫ומזוהים על ידי המהדר בעזרת מילים שמורות ותו '‪':‬‬
‫פקודות מופרדות לרוב על ידי מעבר שורה‪ .‬שימוש בתו ';'‬ ‫‪‬‬
‫)נקודה ופסיק( להפרדה בין פקודות הוא אופציונלי‪.‬‬
‫הזחה קובעת את גבולות‬
‫הבלוק‬
WHITESPACE MATTERS!
‫שפת מכונה ושפת תכנות‬
‫שפת מכונה – זו השפה בה המחשב מדבר והיא כוללת ‪ 2‬אותיות בלבד ‪ 0‬ו‪.1‬‬
‫נקראת גם שפה בינארית‪ .‬זו שפה מורכבת מאוד‪ .‬בקידוד בינארי בלתי אפשרי‬
‫לכתוב תוכנות מורכבות‪.‬‬
‫לכן‪ ,‬פיתחו את שפות התכנות העיליות‪ ,‬המאפשרות כתיבה במילים ובתחביר‬
‫אנושי‪ ,‬שמובן יותר לבני אדם וקל יחסית לזכירה‪ .‬יש הרבה שפות תכנות‬
‫כשהנפוצות הן ‪ ,c++‬ג'אווה ופייתון‪.‬‬

‫מהדר )‪(COMPILER‬‬
‫כל מחשב מסוגל להריץ תוכניות הכתובות בשפת מכונה )שפת ‪ 0‬ו‪ .(1‬לכן‪ ,‬על‬
‫מנת להריץ תוכנית מסוימת‪ ,‬הכתובה בשפה שאינה שפת המכונה של המחשב‬
‫המריץ‪ ,‬ראשית יש לתרגמה לשפה זו‪.‬‬
‫בסיום התרגום נוצר קובץ הכתוב בשפת מכונה‪ ,‬הניתן להרצה בכל עת‪ .‬הקובץ‬
‫שנוצר‪ ,‬מבוצע ישירות על המעבד‪.‬‬
‫תרגום זה מבוצע על ידי מהדר )‪(Compiler‬‬

‫המפרש )‪(INTERPRETER‬‬
‫קיימת דרך אחרת שבה יכולים מחשבים לבצע את התוכניות המוצגות להם‪.‬‬
‫בדרך זו לא מתורגמת התכנית כולה לשפה ברמה נמוכה יותר‪ .‬במקום זאת כל‬
‫אחד מן המשפטים העיליים בתכנית מתורגם ברגע שמגיעים אליו להוראות‬
‫בשפת מכונה והוא מבוצע מיד‪.‬‬
‫המנגנון האחראי לתרגום מקומי וביצוע מידי הוא המפרש )‪.(Interpreter‬‬

‫בפייתון פשוט כותבים ומריצים‪.‬‬
‫סביבת העבודה של פייתון מגיעה עם מפרש )‪ (Interpreter‬שמאפשר כתיבה ישירה של‬

‫פקודות אליו‪ ,‬אפילו בלי צורך לכתוב תוכנית או קובץ‪.‬‬
‫בצורה כזו מאוד נוח להתנסות בשפה‪,‬‬

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

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

‫קבצי ‪PYC‬‬
‫לאור הבעייתיות שהוצגה‪ ,‬שימוש טהור במפרש נדיר‪ ,‬ונעשה בעיקר ברשת‬
‫האינטרנט‪ ,‬שם יש צורך בגמישות רבה‪.‬‬
‫לרוב‪ ,‬פייתון בדומה לשפות תכנות אחרות‪ ,‬תהדר את הקבצים לשפת ביניים‬
‫נמוכה והם ישמרו בסיומת ‪.pyc‬‬
‫לאחר סיום שלב זה‪ ,‬המפרש יריץ את קוד הביניים‪.‬‬

‫בפייתון אפשר לעשות הכול‬
‫אפשר לעבוד ישירות דרך המפרש‪:‬‬
‫ואפשר לכתוב תוכניות ארוכות בכתבן )‪(editor‬‬

‫התוכנות הנפוצות לתוכניות ארוכות‬
‫לפייתון שתי גרסאות ראשיות‪:‬‬
‫‪ .1‬גרסה ‪.2.X‬‬
‫‪ .2‬גרסה ‪.3.X‬‬
‫זאת אומרת כל מה שמתחיל ב‪ 2‬או ב‪ 3‬ואחרי‬
‫הנקודה מספר כלשהו ‪.‬‬
‫יש הבדלים גדולים ביניהם !‬
‫פייתון ‪ 3.X‬לעומת פייתון ‪2.X‬‬
‫גרסת ‪ 2.7‬יצאה באמצע ‪ .2010‬גרסה זו איננה בפיתוח‬
‫יותר )למעט תיקון באגים(‪ ,‬והתמיכה בה הסתיימה בשנת‬
‫‪.2020‬‬
‫גרסת ‪ 3.0‬יצאה ב‪ 2008‬ומאז כבר יצאו הרבה מהדורות‬

‫מעודכנות‪ .‬וזו הגרסה היציבה של פייתון‪.‬‬
‫פייתון ‪ 3.X‬לעומת פייתון ‪2.X‬‬
‫ישנם הבדלים גדולים בין הגרסאות‬
‫לדוגמה‪:‬‬
‫בגרסה הישנה‪print "The answer is", 2*2 :‬‬
‫בגרסה החדשה‪Print ("The answer is", 2*2) :‬‬
‫ועוד דוגמה‪:‬‬
‫ומתחילים‪...‬‬
‫ערכים‬
‫ערך הוא אחד הדברים הבסיסיים בו משתמשת תכנית מחשב‪.‬‬
‫סוגי הערכים הקיימים בפייתון הם‪:‬‬
‫‪ .1‬מספר שלם ‪ 1,2,13 – int‬וכו'‬
‫‪ .2‬מספר עשרוני ‪ 3.14 ,0.5 – float‬וכו'‬
‫‪ .3‬מחרוזת ‪“hello world” - str‬‬

‫ערכים‬
‫ניתן לשאול באמצעות הפונקציה )(‪ type‬מהו סוג הערך שבידינו‪:‬‬
‫)‪>>> type(3‬‬
‫>’‪<class ‘int‬‬
‫)‪>>> type(3.14‬‬
‫>'‪<class 'float‬‬
‫)"‪>>> type("3.14‬‬
‫>'‪<class 'str‬‬
‫המרת ערכים‬
‫ניתן להמיר ערכים לערכים מסוגים שונים‪:‬‬
‫)‪>>> float(5‬‬
‫‪5.0‬‬
‫)‪>>> int(10.6‬‬
‫‪10‬‬
‫)‪>>> int(-10.6‬‬
‫‪-10‬‬
‫)'‪>>> float('2.5‬‬
‫‪2.5‬‬
‫המרת ערכים‬
.‫ניתן להמיר ערכים לערכים מסוגים שונים‬
:‫ תתקבל שגיאה‬,‫אם ננסה להמיר בצורה לא הגיונית או לא אפשרית‬
>>> str(25)
'25'
>>> int('1p')
Traceback (most recent call last):
File "<interactive input>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '1p'
‫משתנים‬
‫”‪>>>name=“Sharon‬‬ ‫משתנה הוא שם המתייחס לערך‪.‬‬

‫)‪>>>type(name‬‬
‫>’‪<class ‘str‬‬ ‫יצירת משתנה בפייתון היא פשוטה‬

‫‪>>>num=3‬‬
‫מאוד – מציינים את שם המשתנה‬
‫)‪>>>type(num‬‬
‫>’‪<class ‘int‬‬ ‫ואת הערך השייך לו‪.‬‬

‫‪>>>other_num=1.5‬‬
‫)‪>>>type(other_num‬‬ ‫בפייתון אין צורך להצהיר על‬

‫>’‪<class ‘float‬‬
‫סוג הטיפוס או גודלו‬
‫שינוי הערך‬
website = "apple.com"
print(website)
#assigning a new value to website
website = "programiz.com"
Output:
print(website) apple.com
print(type(website)) programiz.com
<class 'str'>
website = 9 <class 'int'>
print(type(website))
‫השמה מרובה‬
‫ניתן לעשות השמה לכמה פרמטרים באופן הבא‪:‬‬

‫"‪a, b, c = 5, 3.2, "Hello‬‬
‫)‪print(a‬‬
‫)‪print(b‬‬
‫)‪print(c‬‬ ‫‪Output:‬‬
‫‪5‬‬
‫‪3.2‬‬
‫‪Hello‬‬
‫השמה מרובה‬
:‫השמה מרובה לערך יחיד אפשר לעשות באופן הבא‬

x = y = z = "same"
print(x)
print(y)
print(z) Output:
same
same
same
‫שמות משתנים ‪ -‬כללים‬
‫• שם משתנה יכול להכיל רק אותיות אנגליות )גדולות או קטנות( או‬

‫ספרות‪ .‬משתנה לא יכול להכיל סימנים מיוחדים כמו‪ # ,! :‬או @‪.‬‬
‫• שם משתנה אינו יכול להתחיל בספרה‪.‬‬
‫• נהוג להשתמש באותיות קטנות באנגלית לשמות משתנים‪ ,‬להשתמש‬

‫באותיות גדולות לקבועים ולהשתמש בקו תחתון כמפריד בין מלים‪.‬‬
‫• אם מנסים להשתמש בשם לא חוקי עבור משתנה‪ ,‬מתקבלת הודעת‬

‫שגיאה‪.‬‬
‫מילים שמורות‬
.‫ בהן אסור להשתמש כשמות משתנים‬,‫ מילים שמורות בפייתון‬33 ‫ישנן‬
:‫מלים אלו הן‬

False await else import pass
None break except in raise
True class finally is return
and continue for lambda try
as def from nonlocal while
assert del global not with
async elif if or yield
‫אופרטורים‬
‫אופרטורים הם סמלים מיוחדים‪ ,‬שמסמלים חישובים פשוטים‬
‫כדוגמת חיבור וכפל‪.‬‬
‫סדר הפעולות בפייתון דומה לסדר הקדימויות המתמטי הרגיל‪:‬‬
‫קודם כל סוגריים‪ ,‬לאחר‪-‬מכן חזקה‪ ,‬כפל וחילוק‪ ,‬חיבור וחיסור‪.‬‬
‫החישוב מתבצע משמאל לימין‪.‬‬

‫אופרטורי פעולה‬
‫דוגמה‬ ‫משמעות‬ ‫אופרטור‬

‫‪2+3=5‬‬ ‫חיבור‬ ‫‪+‬‬
‫‪2-3=-1‬‬ ‫חיסור‬ ‫‪-‬‬
‫‪2*3=6‬‬ ‫כפל‬ ‫*‬
‫‪2**3 = 8‬‬ ‫חזקה‬ ‫**‬
‫‪7/3 = 2.5‬‬ ‫חלוקה ממשית‬ ‫‪/‬‬
‫‪7//3 = 2‬‬ ‫חלוקת שלמים‬ ‫‪//‬‬
‫‪7%3 = 1‬‬ ‫שארית‬ ‫‪%‬‬
‫אופרטורי פעולה ‪ -‬המשך‬
‫דוגמה‬ ‫דוגמה‬ ‫אופרטור‬

‫‪x=5‬‬ ‫‪x=5‬‬ ‫=‬
‫‪x=x+5‬‬ ‫‪x += 5‬‬ ‫=‪+‬‬
‫‪x=x-5‬‬ ‫‪x -= 5‬‬ ‫=‪-‬‬
‫‪x=x*5‬‬ ‫‪x *= 5‬‬ ‫=*‬
‫‪x=x/5‬‬ ‫‪x /= 5‬‬ ‫=‪/‬‬
‫‪x=x%5‬‬ ‫‪x %= 5‬‬ ‫=‪%‬‬
‫‪x = x // 5‬‬ ‫‪x //= 5‬‬ ‫=‪//‬‬
‫אופרטורי השוואה‬

‫‪x == y‬‬ ‫שווה ל‪-‬‬ ‫==‬
‫‪x>y‬‬ ‫גדול מ‪-‬‬ ‫>‬
‫‪x<y‬‬ ‫קטן מ‪-‬‬ ‫<‬
‫‪x!=y‬‬ ‫שונה מ‪-‬‬ ‫=!‬
‫‪x<=y‬‬ ‫קטן מ‪ -‬או שווה ל‪-‬‬ ‫=<‬
‫‪x>=y‬‬ ‫גדול מ‪ -‬או שווה ל‪-‬‬ ‫=>‬
PRINT-‫פונקציית ה‬
name=“Yoram”
num=3
other_num=1.5
print (name)
Output:
print (num) ‘Yoram’
3
print (other_num)
1.5
‫פונקציית ה‪PRINT-‬‬
‫שימו לב שפונקציית ה‪ print‬מוסיפה באופן‬

‫דיפולטיבי ירידת שורה בסופה‪.‬‬
‫אם נרצה לשנות זאת‪ ,‬לדוגמה‪ ,‬לרווח‬

‫במקום ירידת שורה‪ ,‬נעשה זאת כך‪:‬‬
‫)' '=‪print(“hello world”, end‬‬

:‫עוד אופציות‬
print(1, 2, 3, 4)
print(1, 2, 3, 4, sep='*')
print(1, 2, 3, 4, sep='#', end='&')
Output:
1234
1*2*3*4
1#2#3#4&
INPUT-‫פונקציית ה‬
‫ על מנת לקרוא קלט מהמשתמש‬input ‫נשתמש בפונקציה‬
name=input(“please enter your name: ”)
print (name)
Output:
please enter your name: Sharon
‘Sharon’
string ‫ מחזירה‬input() ‫שימו לב! הפונקציה‬
int‫ יש לעשות המרה מפורשת ל‬,‫כאשר אנו מעוניינים לקלוט מספר‬
num = input(“please enter a number: “)

type(num)
Output:
num = int(num)
print(num+2) please enter a number: 5
<class ‘str’>
7
‫כמה נקודות נוספות‪:‬‬
‫• כמו בשפות רבות אחרות‪ ,‬התו ’‪ ‘\n‬בפונקציה ‪ print‬משמעותו שורה חדשה‬
‫• הערה בקוד תסומן על ידי ‪ #‬בתחילת השורה‬
‫=============== ‪#=============== class ex1‬‬
‫• הערה בת כמה שורות תתחיל ותסתיים על ידי ‪ 3‬מרכאות‬
‫=============== ‪"""=============== class ex1‬‬
‫"""‪This program implements a calculator‬‬
‫• שורה ארוכה אפשר לחלק בצורה הזו‪:‬‬
‫\‪a=1+2+3+‬‬
‫\‪4+5+6+‬‬
‫‪7+8+9‬‬
‫•כשזה בתוך סוגריים‪ ,‬אין צורך להוסיף כלום‪:‬‬
‫‪a = (1 + 2 + 3 +‬‬
‫‪4+5+6+‬‬
‫)‪7 + 8 + 9‬‬
2 ‫שבוע‬ ‫רות בורנשטין‬
rutbor@edu.hac.ac.il
‫אופרטורים‬
‫אופרטורים הם סמלים מיוחדים‪ ,‬שמסמלים חישובים פשוטים כדוגמת חיבור וכפל‪.‬‬
‫סדר הפעולות בפייתון דומה לסדר הקדימויות המתמטי הרגיל‪:‬‬
‫קודם כל סוגריים‪ ,‬לאחר‪-‬מכן חזקה‪ ,‬כפל וחילוק‪ ,‬חיבור וחיסור‪ .‬החישוב מתבצע משמאל‬
‫לימין‪.‬‬
‫אופרטורי פעולה‬

‫‪2+3=5‬‬ ‫חיבור‬ ‫‪+‬‬
‫‪2-3=-1‬‬ ‫חיסור‬ ‫‪-‬‬
‫‪2*3=6‬‬ ‫כפל‬ ‫*‬
‫‪2**3 = 8‬‬ ‫חזקה‬ ‫**‬
‫‪7/3 = 2.5‬‬ ‫חלוקה ממשית‬ ‫‪/‬‬
‫‪7//3 = 2‬‬ ‫חלוקת שלמים‬ ‫‪//‬‬
‫‪7%3 = 1‬‬ ‫שארית‬ ‫‪%‬‬
‫אופרטורי פעולה ‪ -‬המשך‬
‫דוגמה‬ ‫דוגמה‬ ‫אופרטור‬

‫‪x=5‬‬ ‫‪x=5‬‬ ‫=‬
‫‪x=x+5‬‬ ‫‪x += 5‬‬ ‫=‪+‬‬
‫‪x=x-5‬‬ ‫‪x -= 5‬‬ ‫=‪-‬‬
‫‪x=x*5‬‬ ‫‪x *= 5‬‬ ‫=*‬
‫‪x=x/5‬‬ ‫‪x /= 5‬‬ ‫=‪/‬‬
‫‪x=x%5‬‬ ‫‪x %= 5‬‬ ‫=‪%‬‬
‫‪x = x // 5‬‬ ‫‪x //= 5‬‬ ‫=‪//‬‬
‫אופרטורי השוואה‬

‫‪x == y‬‬ ‫שווה ל‪-‬‬ ‫==‬
‫‪x>y‬‬ ‫גדול מ‪-‬‬ ‫>‬
‫‪x<y‬‬ ‫קטן מ‪-‬‬ ‫<‬
‫‪x!=y‬‬ ‫שונה מ‪-‬‬ ‫=!‬
‫‪x<=y‬‬ ‫קטן מ‪ -‬או שווה ל‪-‬‬ ‫=<‬
‫‪x>=y‬‬ ‫גדול מ‪ -‬או שווה ל‪-‬‬ ‫=>‬
name=“Yoram”
num=3
other_num=1.5
print (name)
Output:
print (num) ‘Yoram’
3
print (other_num)
1.5
‫פונקציית ה‪PRINT-‬‬
‫שימו לב שפונקציית ה‪ print‬מוסיפה באופן‬
‫דיפולטיבי ירידת שורה בסופה‪.‬‬
‫אם נרצה לשנות זאת‪ ,‬לדוגמה‪ ,‬לרווח‬

‫במקום ירידת שורה‪ ,‬נעשה זאת כך‪:‬‬
‫)' '=‪print(“hello world”, end‬‬

:‫עוד אופציות‬
print(1, 2, 3, 4)
print(1, 2, 3, 4, sep='*')
print(1, 2, 3, 4, sep='#', end='&')
Output:
1234
1*2*3*4
1#2#3#4&
‫ על מנת לקרוא קלט מהמשתמש‬input ‫נשתמש בפונקציה‬
name=input(“please enter your name: ”)
print (name)
Output:
please enter your name: Sharon
‘Sharon’
string ‫ מחזירה‬input() ‫שימו לב! הפונקציה‬
int‫ יש לעשות המרה מפורשת ל‬,‫כאשר אנו מעוניינים לקלוט מספר‬
num = input(“please enter a number: “)

type(num)
Output:
num = int(num)
please enter a number: 5
print(num+2)
<class ‘str’>
7
‫• כמו בשפות רבות אחרות‪ ,‬התו ’‪ ‘\n‬בפונקציה ‪ print‬משמעותו שורה חדשה‬
‫• הערה בקוד תסומן על ידי ‪ #‬בתחילת השורה‬
‫=============== ‪#=============== class ex1‬‬
‫• הערה בת כמה שורות תתחיל ותסתיים על ידי ‪ 3‬מרכאות‬
‫=============== ‪"""=============== class ex1‬‬
‫"""‪This program implements a calculator‬‬
‫• שורה ארוכה אפשר לחלק בצורה הזו‪:‬‬
‫\‪a=1+2+3+‬‬
‫\‪4+5+6+‬‬
‫‪7+8+9‬‬
‫•כשזה בתוך סוגריים‪ ,‬אין צורך להוסיף כלום‪:‬‬
‫‪a = (1 + 2 + 3 +‬‬
‫‪4+5+6+‬‬
‫)‪7 + 8 + 9‬‬
IF STATEMENT
a = 21
b = 10
If (a == b):
print (“a is equal to b”)
else:
print (“a is not equal to b”)
IF STATEMENT
a = 21
b = 10
If (a == b):
else:
if (a<b):
print (“a is less than b”)
else:
print (“a is not less than b”)
‫‪ELIF‬‬
‫במקום לכתוב ‪else‬‬
‫ובתוך הבלוק שלו להוסיף תנאי חדש‪,‬‬
‫השתמשו פשוט ב‪.elif‬‬

ELIF
a = 21
b = 10
If (a == b):
elif (a<b):
else:
ELIF
IF STATEMENT
a = input(“Please enter a number: ”)
b = input(“Please enter another number: ”)
If (a == b):
elif (a<b):
else:
‫מבני נתונים ‪ -‬רשימות )‪(LISTS‬‬
‫רשימות הן טיפוס הנתונים השמיש ביותר – "סוס העבודה" של התכנות בפיתון!‬
‫תפקידו של טיפוס הרשימה להחזיק רשימה מסודרת של נתונים‪.‬‬
‫הגדרת רשימה נעשית ע"י שימוש באופרטור סוגרים מרובעים‪[ ] :‬‬

‫מבני נתונים ‪ -‬רשימות )‪(LISTS‬‬
‫שימו לב‪:‬‬
‫‪ ‬אין צורך להצהיר על גודל הרשימה‪.‬‬
‫‪ ‬רשימה אחת יכולה להכיל טיפוסים מסוגים שונים‪.‬‬

‫פנייה לערך ברשימה‬
‫פונקציות הרשימה‬
‫• כל רשימה היא למעשה אובייקט‪.‬‬

‫• לאובייקט הרשימה פונקציות פנימיות המאפשרות הוספה‪,‬‬
‫הסרה ומיון של איברי הרשימה‪.‬‬
‫דוגמאות לפונקציות של רשימה‬
‫אבל אפשר לעשות זאת יותר פשוט ‪..‬‬
‫]‪>>> x = [1, 2, 3, 4, 5‬‬

‫‪>>> x‬‬
‫]‪[1, 2, 3, 4, 5‬‬
‫]‪>>> x = x + [6‬‬
‫‪>>> x‬‬
‫]‪[1, 2, 3, 4, 5, 6‬‬
‫‪>>> x[0] = 7‬‬
‫‪>>> x‬‬
‫]‪[7, 2, 3, 4, 5, 6‬‬
‫‪>>> x * 3‬‬
‫]‪[7, 2, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6‬‬
‫‪SLICE OPERATION‬‬
‫ניתן לקבל תתי‪-‬רשימות מתוך רשימה על ידי הגדרת שני אינדקסים‪ ,‬מופרדים על ידי‬
‫נקודתיים‪.‬‬
‫הערך המוחזר מביטוי כזה יהיה רשימה המכילה את האלמנטים של הרשימה המקורית‬
‫לפי הסדר החל מהאינדקס הנתון הראשון ועד האינדקס האחרון‪ ,‬לא כולל‪.‬‬
‫])‪lst[begin_index:end_index(not included‬‬
SLICE OPERATION – EXAMPLES
Output:
['eggs', 'milk', 100, 7, 5.14]
['milk’, 100]
[100, 7]
‫‪SLICE OPERATION‬‬
‫אם רוצים לקחת מתחילת הרשימה או עד סופה‪ ,‬אפשר פשוט להשאיר ריק‪ ,‬ללא אינדקס‪.‬‬
‫אם רוצים מתחילת הרשימה‪:‬‬
‫])‪lst[:end_index(not included‬‬
‫אם רוצים עד סופה‪:‬‬
‫]‪lst[begin_index:‬‬
Output:
Output:
‫‪SLICE OPERATION - CONTINUE‬‬
‫ניתן להוסיף נקודותיים שניות כדי להגדיר את גודל הדילוג בין האלמנטים ברשימה וכך‬
‫לקבל תת רשימה שאינה רציפה‪.‬‬
‫הערך המוחזר מביטוי כזה יהיה רשימה המכילה את האלמנטים של הרשימה המקורית‬
‫לפי הסדר החל מהאינדקס הנתון הראשון ועד האינדקס האחרון )לא כולל( עם דילוגים‪.‬‬
‫]‪lst[begin_index:end_index:step‬‬
Output:
['eggs', 'milk', 100, 7, 5.14, ‘bread’, ‘meat’, 56]
[‘milk’, 7]
[100, ‘bread’]
Output:
Output:
SLICE OPERATION
LIST FUNCTIONS
• len(lst): number of elements in list.
Example: len ([1, 6, 2, 4.6, 1.11, 0.043, 5 ]) 7
• min(lst): smallest element. Must all be the same type!

Example: min([1, 6, 2, 4.6, 1.11, 0.043, 5 ]) 0.043
• max(lst): largest element, all must be the same type
Example: max([1, 6, 2, 4.6, 1.11, 0.043, 5 ]) 6
• sum(lst): sum of the elements, numeric only
Example: sum([1, 6, 2, 4.6, 1.11, 0.043, 5 ]) 19.753

MORE ACTIONS IN LISTS
Results
s=[1,2,3,4]
t=[1,3,5,3,7,3,2,5,3]
x=2
print (s + t) [1, 2, 3, 4, 1, 3, 5,3, 7, 3, 2, 5, 3]
print(t.index(3)) 1
print(t.count(3)) 4
IN AND NOT IN
Results
s=[1,2,3,4]
t=[1,3,5,3,7,3,2,5,3]
x=2
print (x in s) True
print (7 not in s) True

‫מה קרה כאן?‬
‫]‪my_list = [4, 7, 1, 2‬‬
‫)(‪my_list = my_list.sort‬‬
‫)‪print (my_list‬‬ ‫‪None‬‬
‫למה?‬
‫רשימה היא מסוג ‪ ,mutable‬ז"א היא ניתנת לשינוי‪ ,‬ולכן מרבית‬
‫הפונקציות של רשימה משנות את הרשימה עצמה ומחזירות‬
‫‪.None‬‬
‫במקרה הזה הפונקציה מחזירה ‪ None‬ואותו אנו שומרים בתוך‬
‫‪my_list‬‬
‫מטריצה‬
‫• ניצור מטריצה כך‪:‬‬
‫]]‪my_list = [ [1, 2, 3], [4, 5, 6], [7, 8, 9‬‬
‫• אם נרצה להדפיס את העמודה השניה בשורה השניה‪ ,‬נעשה זאת כך‪:‬‬
‫)]‪print (my_list[1][1‬‬
‫• ואפשר כמובן לערבב‪:‬‬
‫]'‪my_list = ['a', [1, 2, 3], 'z‬‬
‫• ואם נרצה להדפיס את הספרה ‪ ,1‬נכתוב‪:‬‬
‫)]‪print (my_list[1][0‬‬
‫לולאות ‪FOR‬‬
‫לולאת ה‪ for‬תמיד עוברת על פריטים ברצף כלשהו לפי סדר הופעתם ברצף‪.‬‬
‫שימו לב‪ ,‬בפייתון אנו עוברים על האובייקטים עצמם ולא על האינדקס!‬

FOR IN LIST
FOR IN LIST
‫עוד מבני נתונים‬ ‫רות בורנשטין‬
‫‪rutbor@edu.hac.ac.il‬‬
‫‪TUPLE‬‬
‫‪ Tuple‬הוא טיפוס של רשימה קבועה‪ .‬השימוש שלו הוא עבור אחסון מידע שאין צורך‬
‫לשנותו )או שיש צורך לוודא שהוא לא ישתנה(‬
‫בהמשך נראה שפונקציה יכולה להחזיר רק איבר אחד‪ .‬אבל ניתן להחזיר מפונקציה ‪Tuple‬‬
‫המכיל מספר איברים‪ ,‬וע"י כך להחזיר יותר מאיבר אחד מפונקציה‪.‬‬
‫‪TUPLE - CONTINUE‬‬
‫)‪>>> t = (1, 2, 3‬‬ ‫יצירת ה‪ Tuple‬נעשית בדיוק כמו‬
‫‪>>> t‬‬ ‫יצירת רשימה‪ ,‬רק שבמקום סוגריים‬
‫)‪(1, 2, 3‬‬ ‫מרובעות משתמשים בסוגריים‬
‫]‪>>> t[0‬‬
‫עגולות‪.‬‬
‫‪1‬‬
TUPLE ‫אי אפשר לשנות‬
>>> t[0] = 2 ‫ נקבל‬,tuple‫אם ננסה לשנות איבר ב‬
‫הודעת שגיאה‬
File "<stdin>", line 1, in <module>
TypeError: object doesn't support item

assignment
‫אי אפשר לשנות ‪TUPLE‬‬
‫אם ננסה לשנות איבר ב‪,tuple‬‬
‫נקבל הודעת שגיאה‪.‬‬
‫אבל אם אנחנו משנים תוכן‬

‫של משתנה שנמצא בתוך‬
‫‪ ,tuple‬הוא כן משתנה‪.‬‬
‫‪ TUPLE‬ריק ושירשור של ‪TUPLES‬‬
‫)( = ‪>>> empty_tuple‬‬
‫ניתן ליצור ‪ tuple‬ריק‬
‫)‪>>> t1 = (1, 2, 3‬‬
‫)‪>>> t2 = (4, 5, 6‬‬ ‫ניתן לשרשר שני ‪tuple‬ים‬
‫‪>>> t1 + t2‬‬
‫)‪(1, 2, 3, 4, 5, 6‬‬
‫‪TUPLE ASSIGNMENTS‬‬
‫)‪>>> (a, b, c) = (1, 2, 3‬‬
‫בעזרת שני ‪tuple‬ים‪ ,‬ניתן ליצור השמה‬
‫‪>>> a‬‬
‫‪1‬‬ ‫מרובה‪.‬‬
‫‪>>> b‬‬
‫כמובן רק במידה וזה הגיוני‪.‬‬
‫‪2‬‬
‫‪>>> c‬‬ ‫אם לא‪ ,‬נקבל הודעת שגיאה‪.‬‬
‫‪3‬‬
‫)‪>>> (1, 2, 3) = (1, 2, 3‬‬
‫‪SyntaxError: can't assign to literal‬‬
‫מילונים‬
‫מילון הוא מבנה נתונים שכל איבר בו מורכב משניים‪:‬‬
‫מפתח )‪ (key‬וערך המתאים לו )‪.(value‬‬
‫מפתח הוא ייחודי‪ .‬ז"א‪ ,‬הוא יכול להופיע פעם אחת ולא יותר‪.‬‬
‫מילון מוגדר באמצעות סוגריים מסולסלים‪.‬‬

‫מילונים – הכנסת ערכים‬
‫שתי דרכים להכניס ערכים למילון‪:‬‬
‫‪ .1‬הכנסת כל הערכים בעת הגדרת המילון‬
‫}… ‪my_dict = {key1: value1, key2: value2,‬‬
‫‪ .2‬יצירת מילון ריק והכנסת הערכים לאחר מכן‬
‫}{ = ‪my_dict‬‬
‫‪my_dict[key1] = value1‬‬
‫מילונים‬
‫יצירת מילון ריק נעשית בעזרת סוגריים מסולסלות ריקות‬
‫}{ = ‪>>> d‬‬
‫הוספת ערך הממופה למפתח ‪1‬‬
‫"‪>>> d[1] = "Sunday‬‬
‫‪>>> d‬‬
‫}'‪{1: 'Sunday‬‬
‫]‪>>> d[1‬‬
‫'‪'Sunday‬‬
‫עוד דוגמא למילון‬
cap = {}
cap['Israel'] = 'Jerusalem'
cap['USA'] = 'Washington'
cap['Russia'] = 'Moscow'
cap['France'] = 'Paris'
cap['England'] = 'London'
cap[‘Italy'] = 'Rome‘
‫צורות הצגה שונות של המילון‬
>>> cap
{'Israel': 'Jerusalem', 'USA': 'Washington', 'Russia': 'Moscow', 'France': 'Paris', 'England':
'London', 'Italy': 'Rome'}
>>> cap.keys()
dict_keys(['Israel', 'USA', 'Russia', 'France', 'England', 'Italy'])
>>> cap.values()
dict_values(['Jerusalem', 'Washington', 'Moscow', 'Paris', 'London', 'Rome'])
‫פונקציות שימושיות למילונים‬
>>> cap.items()
[('Israel', 'Jerusalem'), ('Italy', 'Rome'), ('USA', 'Washington'), ('France',
'Paris'), ('England', 'London'), ('Russia', 'Moscow')]
>>> len(cap)
6
‫מציאת ערך במילון בעזרת המפתח שלו‬
‫]'‪>>> cap['France‬‬
‫בשונה מרשימה‪ ,‬בה ניגש לערך באמצעות‬
‫'‪'Paris‬‬
‫]'‪>>> cap['Japan‬‬ ‫האינדקס שלו‪ ,‬במילון ניגש לערך באמצעות‬
‫‪Traceback (most recent call last):‬‬
‫המפתח שלו‪.‬‬
‫>‪File "<stdin>", line 1, in <module‬‬
‫‪KeyError: Japan‬‬ ‫גישה לערך שלא קיים‪ ,‬תיתן שגיאה‪.‬‬
‫שינוי ערך במילון‬
‫המפתחות במילון ייחודיים ולא ניתן לחזור על‬
cap={}
‫ זה‬,‫ כאשר ננסה לעשות זאת‬.‫מפתח פעמיים‬
cap['Israel'] = 'Jerusalem'
.‫ייתפס כשינוי הערך‬
cap['USA'] = 'Washington‘
… Output:
{'Israel': 'Jerusalem', 'USA': 'Washington',
print(cap)
…}
cap['USA'] = 'New York' {'Israel': 'Jerusalem', 'USA': 'New York',
print(cap) …}
‫‪SET‬‬
‫}‪>>> x = {1, 2, 3‬‬
‫‪ set‬היא כמו רשימה‪ ,‬מלבד העובדה שאי‪-‬‬
‫‪>>> x‬‬
‫אפשר לאחסן פעמיים את אותו האיבר‪ .‬כדי‬
‫}‪{1, 2, 3‬‬
‫ליצור קבוצה מרשימת איברים משתמשים‬
‫)‪>>> x.add(2‬‬
‫)‪>>> x.add(3‬‬ ‫בסוגריים מסולסלים‪.‬‬
‫)‪>>> x.add(4‬‬
‫ל‪ set‬אפשר להוסיף איברים‪ .‬אם ננסה‬
‫‪>>> x‬‬
‫להוסיף איבר שקיים כבר‪ ,‬לא יקרה כלום‪.‬‬
‫}‪{1, 2, 3, 4‬‬
‫מחיקת איבר ב‪ .SET‬פונקציות ‪ REMOVE‬ו‪DISCARD‬‬
‫‪2‬‬ ‫‪1‬‬
‫הפתרון הוא להשתמש בפונקציית‬ ‫מ‪ set‬אפשר למחוק איברים‪.‬‬
‫‪ discard‬שמוחקת את האיבר רק‬ ‫אם ננסה למחוק איבר שאינו קיים‪,‬‬
‫במידה והוא קיים‬ ‫נקבל הודעת שגיאה‪:‬‬
‫)‪>>> x.discard(5‬‬ ‫)‪>>> x.remove(1‬‬
‫)‪>>> x.discard(2‬‬ ‫)‪>>> x.remove(5‬‬
‫‪>>> x‬‬ ‫‪Traceback (most recent call last):‬‬
‫}‪{3, 4‬‬ ‫‪File "<stdin>", line 1, in‬‬
‫>‪<module‬‬
‫‪KeyError: 5‬‬
‫‪>>> x‬‬
‫}‪{2, 3, 4‬‬
‫מחיקת ערך כפול מרשימה‬
>>> w = [1, 1, 1, 2, 3, 9, 2, 4, 3, 6]
>>> set(w)
{1, 2, 3, 4, 6, 9}
>>>basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>>basket
{'apple', 'orange', 'pear', 'banana'}

‫חיסור רשימות‬
‫‪ set‬מאפשר לנו לעשות חיסור‪,‬‬
‫מה שאי אפשר לעשות ברשימות‪.‬‬
‫‪Output:‬‬
SET‫ ב‬IN ‫פקודת‬
False ‫ או‬True ‫ בודקת האם האובייקט קיים ומחזירה‬in ‫פקודת‬
{'apple', 'orange', 'pear', 'banana'}
>>>'orange' in basket
True
>>>'crabgrass' in basket
False
‫ניתן לחפש גם ערך בתוך מילון בצורה הזו‬
>>> cap['France']
'Paris'
>>> cap['Japan']
File "<stdin>", line 1, in <module>
KeyError: Japan
>>> 'Japan' in cap
False
>>> 'Israel' in cap
True
SORTED SET
To loop over a (uniqe) sequence in sorted order
‫ממבנה נתונים אחד לאחר‬
>>> set([1,2,3])
{1, 2, 3}
>>> tuple({5,6,7})
(5, 6, 7)
>>> list('hello')
['h', 'e', 'l', 'l', 'o’]
>>> dict([[1,2],[3,4]])
{1: 2, 3: 4}
>>> dict([(3,26),(4,44)])
{3: 26, 4: 44}
‫לולאות ‪FOR‬‬
‫לולאת ה‪ for‬תמיד עוברת על פריטים ברצף כלשהו לפי סדר הופעתם ברצף‪.‬‬
‫שימו לב‪ ,‬בפייתון אנו עוברים על האובייקטים עצמם ולא על האינדקס!‬

FOR IN LIST
FOR IN LIST
FOR IN DICT
for x in cap:
print(x," : ",cap[x])
Output:
USA : New York
Russia : Moscow
France : Paris
England : London
‫‪RANGE‬‬
‫‪ range‬יוצרת רצף מספרים עם ערך התחלתי‪ ,‬ערך סופי וקפיצה‪.‬‬
‫ישנן שלוש אפשרות ליצור ‪:range‬‬
‫)‪1. range(end‬‬ ‫יווצר רצף מספרים מ‪ 0‬ועד ‪ end‬בצורה רציפה‬
‫)‪2. range(start, end‬‬ ‫יווצר רצף מספרים מ‪ start‬ועד ‪ end‬בצורה רציפה‬
‫)‪3. range(start, end, step‬‬ ‫יווצר רצף מספרים מ‪ start‬ועד ‪end‬‬

‫בדילוגים של ‪step‬‬
RANGE
:range-‫דוגמאות ל‬
range(10) 0123456789
range (5,15) 5 6 7 8 9 10 11 12 13 14 15
range(8,27,2) 8 10 12 14 16 18 20 22 24 26
range(48,20,-3) 48 45 42 39 36 33 30 27 24 21
RANGE
:‫ נקבל‬range ‫אם נבדוק מהו הסוג של‬
>>> type(range(1,10))
<class 'range’>
:‫ לדוגמה‬.‫ בתוך משתנה‬range ‫ניתן לשמור‬
my_range = range(34, 78)

RANGE
:‫ נקבל‬,‫אם ננסה להדפיס אותו‬
>>>print(range(10))
range(0, 10)
:‫ נקבל‬,‫אם נמיר אותו לרשימה‬
>>>print(list(range(2, 8)))
[2, 3, 4, 5, 6, 7]
>>>print(list(range(2, 20, 3)))
[2, 5, 8, 11, 14, 17]

FOR WITH RANGE - 1
for num in range(3):

print(num)
Output:
0
1
2
FOR WITH RANGE - 2
for num in range(3,6) :
print(num)
Output:
3
4
5
FOR WITH RANGE - 3
for num in range(3,13,4):
print(num)
Output:
3
7
11
‫מעבר על לולאה בעזרת אינדקס‬
‫]'‪genre = ['pop', 'rock', 'jazz‬‬

‫‪for i in range(len(genre)) :‬‬
‫)]‪print("I like", genre[i‬‬
‫שימו לב! זו צורת כתיבה שרגילים להשתמש בה ב‪ ++C‬אבל בפייתון זו לא הצורה הרגילה‪.‬‬
‫שימו לב שיש לכם סיבה טובה להשתמש בה כי אחרת זה יכול להיחשב כשגיאה!‬
BREAK, CONTINUE AND ELSE
for statement_list_1 :
if test1:
break Exit loop now; skip else
if test2:
continue Go to top of loop now
else:
statement_list_2 If we didn't hit a 'break'
BREAK AND CONTINUE STATEMENTS
break statement breaks out of the smallest enclosing for or while loop.
continue statement continues with the next iteration of the loop.
-- both statements work just like in C.
CONTINUE
for val in "string": Output:

if val == "i": s
t
continue r
print(val) n
g
print("The end")
The end
FOR WITH ELSE
digits = [0, 1, 5]
for i in digits:
print(i)
else:
Output:
print("No items left.") 0
1
5
No items left.
1‫רב‬
ELSE CLAUSES ON LOOPS

student_name = 'Soyuj'
marks = {'James': 90, 'Jules': 55, 'Arthur': 77}
for student in marks :
if student == student_name :
Output:
print(marks[student])
'No entry with
break that name
else : found
print('No entry with that name found.’)
‫שקופית ‪40‬‬
‫רות בורנשטין‪04/03/2021 ,‬‬ ‫רב‪1‬‬

ELSE CLAUSES ON LOOPS
Loop statements may have an else clause that's executed when the
loop was not terminated by a break.
WHILE ‫לולאת‬
Output:
a=0 1
2
while a < 10: 3
a=a+1 4
print (a) 5
6
7
8
9
10
‫מחרוזות פשוטות‬
‫מחרוזת היא רצף של תווים‪ ,‬המשמשת בדרך כלל לביטוי מילים או משפטים‪.‬‬
UNLIKE LIST -- PYTHON STRINGS CANNOT BE
CHANGED — THEY ARE IMMUTABLE.
THEREFORE, ASSIGNING TO AN INDEXED
POSITION IN THE STRING RESULTS IN AN
ERROR:
SPLIT FUNCTION
:split '‫• ניתן להמיר מחרוזת לרשימה בעזרת הפונ‬
str= 'this is a test‘
split_list = str.split()
print(split_list) ['this', 'is', 'a', 'test']
:‫• אפשר גם כך‬
split_list = 'this is a test'.split()
print(split_list) ['this', 'is', 'a', 'test']
‫‪SPLIT FUNCTION‬‬
‫הפונ' הזו תהיה שימושית מאוד כשנרצה לקלוט פלט מהמשתמש‪.‬‬
‫אם נרצה לדוגמה לקלוט שלושה מספרים‪ ,‬נעשה זאת כך‪:‬‬
‫)(‪lst=input(“please enter 3 numbers”).split‬‬
‫מה שנקבל יהיה‪:‬‬
‫‪lst‬‬ ‫]’‪[‘1’, ‘2’, ‘3‬‬
‫שימו לב שכל המספרים הם כרגע ‪ string‬וצריך לעבור על כל מספר בנפרד ולהמיר אותו‬
‫ל‪.int‬‬
STRING‫פונקציות שימושיות ל‬
>>>str=‘a child, Yossi go and meet his friend, also Yossi. Together, they go to eat
pizza.’
>>>str.split(‘Yossi’)
[‘a child, ‘,’ go and meet his friend, also ‘, ‘. Together, they go to eat pizza.’]
>>>‘A child, Yossi walks and meets his friend, also Yossi. Together, they go to eat
pizza’.replace(‘Yossi’, ’Dani’)
‘A child, Dani walks and meets his friend, also Dani. Together, they go to eat
pizza'
‫עוד פונקציות שימושיות‬
‫‪str.startswith(‘something’) -‬‬
‫פונקציה בוליאנית המחזירה '‪ 'True‬אם המחרוזת מתחילה ב‪‘something’-‬‬
‫‪str.endswith(‘something’) -‬‬
‫פונקציה בוליאנית המחזירה '‪ 'True‬אם המחרוזת מסתיימת ב‪‘something’-‬‬
‫)'‪len('Hello‬‬
‫פונקציה המחזירה את אורך המחרוזת‪.‬‬
‫ועוד כמה‬
‫)(‪str.strip‬‬
‫פונקציה המורידה את כל ה‪ whitespace-‬שנמצאים בקצות המחרוזת‬
‫)'‪'Hello'.index('H‬‬
‫פונקציה המחזירה את המקום הראשון בו תת המחרוזת מופיעה‪ .‬אם ננסה לחפש תו שאינו מופיע‪,‬‬
‫נקבל הודעת שגיאה‪.‬‬
‫)'‪'Hello'.find('b‬‬
‫כנ"ל‪ .‬במקרה הזה‪ ,‬כש‪ b‬לא מופיעה‪ ,‬הפלט יהיה ‪.-1‬‬
‫ועוד‬
>>>’Yossi’.upper()
‘YOSSI’
>>>’Yossi’.lower()
‘yossi’
‘hello world’.title()
‘Hello World’
‫‪MULTILINE STRING‬‬
‫ניתן להשתמש ב """ )שלוש מרכאות צמודות( על‪-‬מנת לפרוס טקסט על גבי‬
‫מספר שורות‪.‬‬
‫דוגמא‪:‬‬
PRINT FORMAT STRINGS
>>>name = ‘Shuly’
>>>print ("I am {} years old and my cat is {}".format('17', name) )
I am 17 years old and my cat is Shuly
>>>print('coordinates: {xpoint},{ypoint}'.format(xpoint=4.7,
ypoint=2.1))
coordinates: 4.7,2.1
PASS STATEMENTS
The pass statement does nothing!!
It can be used when a statement is required syntactically but the
program requires no action.
For example:
‫בולאנים‬
‫רות בורנשטין‬
‫ו ‪LIST COMPREHENSION‬‬
‫סיכום וחזרה ‪ -‬ערכים‬
‫ראינו מתחילת השנה שיש בפייתון ‪ 3‬סוגי ערכים‪:‬‬
‫‪ .1‬מספר שלם – ‪ .-1,13,100‬מוגדר כ‪int‬‬
‫‪ .2‬מספר עשרוני – ‪ .3.14 ,0.5‬מוגדר כ‪.float‬‬
‫‪ .3‬תו או כמה תווים עם " לפני ואחרי – "‪."7" ,"hello world‬‬

‫מוגדר כ‪.str‬‬
‫שיעור ‪ :3‬פונקציות בסיסי‪ ,‬רשימות‪ ,‬הרכבת רשימות‪ ,‬פילטרים ועוד‬

‫סיכום וחזרה – מבני נתונים‬
‫ראינו מתחילת השנה שיש בפייתון ‪ 4‬סוגי מבני נתונים‪:‬‬
‫‪ .1‬רשימה – כל מה שמוגדר עם ][‪ .‬מאפשרת לשמור הרבה אובייקטים‬

‫מסוגים שונים ולעשות עליהם מגוון פעולות בקלות‪ .‬פניה אל ערך‬
‫ברשימה תתבצע בעזרת האינדקס שלו‪.‬‬
‫]]‪lst = [1,2,45, ‘a’, [6,7,8‬‬
‫‪ – tuple .2‬כל מה שמוגדר עם )(‪ .‬רשימה קבועה‪ ,‬לאחר הגדרתה אין‬

‫אפשרות לשנותה‪.‬‬
‫)]‪tup = (1,2,45, ‘a’, [6,7,8‬‬

‫סיכום וחזרה – מבני נתונים‬
‫‪ .3‬מילון – כל מה שמוגדר עם }{ ומוכנסים אליו זוגות של איברים‪.‬‬

‫המפתחות במילון הם ייחודיים‪ .‬פניה אל ערך במילון תתבצע‬
‫באמצעות המפתח שלו‪.‬‬
‫}]‪dic = {1:2, 45:‘a’, ‘cd’:[6,7,8‬‬
‫‪ – set .4‬כל מה שמוגדר עם }{ ומוכנסים אליו איברים יחידים‪ .‬כל‬

‫איבר יופיע פעם אחת וכפילויות ימחקו‪.‬‬
‫}]‪se = {1,2,45, ‘a’, [6,7,8‬‬

‫סיכום וחזרה ‪ -‬לולאות‬
‫לולאות מוגדרות בעזרת ‪ for‬או ‪ while‬ומאפשרות לנו לעבור‬

‫על רשימה או על טווח מספרים ולעשות על כל אחד‬
‫מהאיברים פעולה מסוימת‪.‬‬
‫אפשר לעבור על האיברים עצמם או לעבור על האינדקס של‬

‫האיברים‪.‬‬

‫ לולאות‬- ‫סיכום וחזרה‬
lst = [1,2,45, ‘a’, [6,7,8]]
for x in lst:
print(x)
for i in range(len(lst)):
print(lst[i])
j=0
while j< len(lst)):
print(lst[j])
j +=1
‫ פילטרים ועוד‬,‫ הרכבת רשימות‬,‫ רשימות‬,‫ פונקציות בסיסי‬:3 ‫שיעור‬

‫בוליאנים‬
‫‪ True‬ו‪ False‬הן מילים שמורות בפייתון‪,‬‬
‫המחזיקות את הערכים ‪ 1‬ו‪ 0‬בהתאמה‪.‬‬
‫אפשר להתייחס אליהן כפרמטרים לכל דבר‪.‬‬
‫להלן הדוגמאות‪:‬‬

‫בוליאנים‬
‫‪>>> True + 1‬‬
‫‪2‬‬
‫‪>>> 0 * True‬‬
‫‪0‬‬
‫‪>>> False * True‬‬
‫‪0‬‬
‫‪>>> False + True‬‬
‫‪1‬‬
‫‪>>> True/False‬‬
‫????‬
TRUTH VALUE TESTING
The following values are considered false:
 None
 False
 Zero of any numeric type. For example: 0 or 0.0
 Any empty sequence. For example: () or []
 Any empty mapping. For example: {}
 instances of user-defined classes, if the class defines a __bool__()
or __len__() method, when that method returns the integer zero or
bool value False
All other values are considered true

‫דוגמאות לבדיקות המחזירות ערכי אמת ושקר‬
‫‪Results‬‬
‫][=‪li‬‬ ‫‪False‬‬
‫‪if li:‬‬
‫)”‪print (“True‬‬
‫‪else:‬‬
‫)”‪print (“False‬‬
‫‪x = None‬‬ ‫‪Empty‬‬
‫‪if x:‬‬
‫)”‪print (“Full‬‬
‫‪else:‬‬
‫)”‪print (“Empty‬‬

‫דוגמאות לפונקציות המחזירות ערכי אמת ושקר‬
‫‪Results‬‬
‫)‪bool(100‬‬ ‫‪True‬‬
‫"‪x = "764bg‬‬ ‫‪False‬‬
‫)(‪x.isdigit‬‬
‫)(‪3.76.is_integer‬‬ ‫‪False‬‬

‫‪ALL AND ANY FUNCTIONS‬‬
‫‪ all ‬בודקת האם כל האיברים ברשימה מקיימים את‬

‫התנאי‪.‬‬
‫)]‪all(x>0 for x in [1,2,-4,5.5‬‬ ‫‪False‬‬
‫‪ any ‬בודקת אם לפחות אחד מהאיברים מקיים את‬

‫התנאי‪.‬‬
‫)]‪any(x>0 for x in [1,2,-4,5.5‬‬ ‫‪True‬‬

‫לולאה אינסופית‬
‫לולאה אינסופית זו לולאה שלא תיגמר אף פעם‪ .‬לדוגמה‪:‬‬
‫‪while True:‬‬
‫)”‪print(“Hello‬‬

‫לולאה אינסופית‬
‫אפשר גם להגדיר תנאי מתי תעצור‪:‬‬
‫‪while True:‬‬
‫)”‪print(“Hello‬‬
‫)” ‪x = input(“Please enter a letter:‬‬
‫‪if x == “e”:‬‬
‫‪break‬‬

‫‪LOGIC GATES‬‬
‫שערים לוגיים הוא תחום גדול ורחב‪.‬‬
‫אנחנו ניגע בו בקטנה בהקשר של‬

‫פייתון‪.‬‬
‫כאשר אנחנו רוצים לבדוק שני תנאים‪.‬‬

‫אנחנו צריכים להחליט האם שניהם‬
‫צריכים להתקיים כדי שהתוצאה תהיה‬
‫אמת או שמספיק לנו שרק אחד מהם‬
‫מתקיים כדי שהתוצאה תהיה אמת‪.‬‬

‫‪AND GATE‬‬
‫השער ‪ AND‬מבטא את הדרישה ששני התנאים יתקיימו כדי שהתוצאה‬
‫תהיה ‪ .True‬בכל מצב אחר‪ ,‬התוצאה תהיה ‪False‬‬

AND GATE
num = int(input(“Please enter a number: “))
if (num > 15) and (num < 20):
print (“The number is - “, num)

‫‪OR GATE‬‬
‫השער ‪ OR‬מבטא את הדרישה שלפחות אחד משני התנאים יתקיים כדי‬
‫שהתוצאה תהיה ‪ .True‬רק אם שני התנאים לא מתקיימים‪ ,‬התוצאה תהיה‬
‫‪False‬‬

OR GATE
if (num < 5) or (num > 15):

NOT GATE
if not num == 7:

‫כתיבה מפורשת שווה לכתיבה עם סימנים‬
‫פייתון מאפשרת את השימוש ב‪ or, and, not‬בצורה המפורשת‬
‫או באמצעות הסימנים המוכרים‪.‬‬
‫‪a and b == a & b‬‬
‫‪a or b == a | b‬‬
‫=! == ‪not‬‬
OR‫השמה מרובה ושימוש ב‬
string1, string2, string3 = '', 'Ron', 'Gal'
non_null = string1 or string2 or string3
print(non_null) Output:
‘Ron’

IF ‫כתיבה מקוצרת של תנאי‬
• employee_bonus = 1000 if sales > 5,000,000 else 0
• age = 15
print('kid' if age < 13 else 'teenager' if age < 18 else
'adult') Output:
teenager

‫השוואת רשימות‬
‫השוואת רשימות מתבצעת אובייקט מול אובייקט משתי‬
‫הרשימות‪.‬‬
‫אם אין הכרעה‪ ,‬ממשיכים לאובייקט הבא‪.‬‬
‫אם יש הכרעה‪ ,‬עוצרים‪.‬‬

‫‪MORE ON CONDITIONS‬‬

‫מיפוי רשימות‬
‫נניח שאנו רוצים לייצר רשימה ובה ריבועי המספרים מ‪ 0‬עד ‪.9‬‬
‫דרך אפשרית אחת היא כדלהלן‪ ,‬בלולאה עם אינדקס ‪ x‬מ‪ 0-‬עד ‪ 9‬בצע‬
‫‪ append‬ל‪.x*x‬‬

‫‪LIST COMPREHENSIONS‬‬
‫דרך אחרת תהיה באמצעות הכללות רשימה ) ‪List‬‬
‫‪.(Comprehensions‬‬
‫הכללות רשימה )‪ (List Comprehensions‬מספקות דרך תמציתית‬
‫ליצירת רשימות‪ .‬יישומים נפוצים הם יצור רשימות חדשות אשר‬
‫בהם כל אלמנט הוא תוצאה של פעולה מוגדרת‪.‬‬
‫דוגמא ליצור רשימה ובה החזקות מ ‪ 0‬עד ‪ 9‬ע"י ‪List‬‬
‫‪.Comprehensions‬‬

‫ דרכים ליצור את אותו דבר‬2
1. h_letters = []
for letter in 'human’:
Output:
h_letters.append(letter)
[‘h’,’u’,’m’,’a’,’n’]
print(h_letters)
2. h_letters = [ letter for letter in 'human’ ]

print( h_letters)

‫‪List Comprehensions‬‬
‫מגוון האופציות ל‪ List Comprehensions‬הוא עצום‪ ,‬נראה מספר דוגמאות נוספות‪:‬‬

DOUBLE IF
num_list = [y for y in range(100)
if y % 2 == 0 if y % 5 == 0]
print(num_list)
Output:
[0,10,20,30,40,50,60,70,80,90]

‫לסיכום‪LIST COMPREHENSIONS ,‬‬
‫• ‪ List Comprehensions‬היא דרך אלגנטית להגדיר וליצור‬

‫רשימות המבוססות על רשימות קיימות‪.‬‬
‫• יצירת רשימה ע"י ‪ List Comprehensions‬היא בדרך כלל‬

‫קומפקטית ומהירה מפונקציות או מלולאות רגילות‪.‬‬

‫לסיכום‪LIST COMPREHENSIONS ,‬‬
‫• עם זאת‪ ,‬עלינו להימנע מכתיבת ‪ List Comprehension‬ארוכה‬
‫מאוד בשורה אחת כדי להבטיח שהקוד יהיה ידידותי‬
‫למשתמש‪.‬‬
‫• כל ‪ List Comprehensions‬אפשר להמיר ללולאה‪ ,‬אבל לא כל‬
‫לולאה ניתן לכתוב בצורה של ‪.List Comprehensions‬‬

‫‪PANDAS‬‬ ‫רות בורנשטין‬
‫‪PANDAS‬‬
‫‪ Pandas‬היא ספריית ‪ Python‬המשמשת לעבודה עם ערכות נתונים‪.‬‬
‫יש לה פונקציות לניתוח‪ ,‬ניקוי‪ ,‬חקירה ומניפולציה של נתונים‪.‬‬
‫הספרייה נוצרה על ידי ווס מקיני ב ‪.2008‬‬

‫למה להשתמש ב‪PANDAS‬‬
‫‪ pandas‬מאפשרת לנו לנתח נתונים גדולים ולהסיק מסקנות על בסיס תיאוריות‬
‫סטטיסטיות‪.‬‬
‫‪ pandas‬יכולה לנקות מערכי נתונים מבולגנים‪ ,‬ולהפוך אותן לקריאות ורלוונטיות‪.‬‬
‫נתונים רלוונטיים חשובים מאוד במדעי הנתונים*‪.‬‬
‫*מדעי נתונים‪ :‬הוא ענף במדעי המחשב בו אנו לומדים כיצד לאחסן‪ ,‬להשתמש ולנתח‬
‫נתונים לצורך הפקת מידע מהם‪.‬‬
‫מה ‪ PANDAS‬עושה?‬
‫‪ Pandas‬עוזרת למצוא את‪:‬‬
‫• ערך המקסימום‪.‬‬
‫• ערך המינימום‬
‫• ערך הממוצע‬
‫• האם יש קורולציה בין שתי עמודות או יותר‪.‬‬
‫בנוסף‪ ,‬אפשר למחוק בקלות שורות שאינן רלוונטיות‪ ,‬או מכילות ערכים שגויים או ריקים‪.‬‬
‫מתחילים לעבוד‬
‫התקנה – שתי אפשרויות‪:‬‬
‫‪ .1‬פתחו את ה‪ command line‬בעזרת הפקודה ‪ cmd‬בשורת החיפוש‪.‬‬
‫לאחר שנפתח החלון השחור‪ ,‬כתבו‪pip install pandas :‬‬
‫‪ .2‬ייבאו את הספרייה ב‪ .pyCharm‬לאחר שמתקבלת שגיאה‪ ,‬יש אופציות לתיקון ושם יש‬
‫אופציה להתקין את הספרייה‪.‬‬
‫דוגמא‬
import pandas as pd
mydataset = {
'cars': ["BMW", "Volvo", "Ford"],
'passings': [3, 7, 2]
}
myvar = pd.DataFrame(mydataset)
print(myvar)
SERIES
‫ממדי המחזיק נתונים מכל סוג‬-‫ זהו מערך חד‬.‫ מייצג טור בטבלה‬pandas‫ ב‬Series
.‫שהוא‬
import pandas as pd
a = [1, 7, 2]
myvar = pd.Series(a)
print(myvar)
LABELS
.‫ים משלך‬label ‫ אפשר ליצור‬index ‫בעזרת הארגומנט‬
import pandas as pd
a = [1, 7, 2]
myvar = pd.Series(a, index = ["x", "y", "z"])
print(myvar)
‫‪LABELS‬‬
‫לאחר יצירת ה‪Label‬ים‪ ,‬אפשר לגשת לערכים בעזרת ה‪Label‬ים החדשים‪:‬‬
‫)]"‪print(myvar["y‬‬
LABELS
:‫ היא בעזרת שימוש במילון בזמן הבניה‬Series ‫עוד דרך ליצירת‬
import pandas as pd
calories = {"day1": 420, "day2": 380, "day3": 390}
myvar = pd.Series(calories)
print(myvar)
LABELS
:‫אם רוצים לקחת רק חלק מתוך הערכים במילון‬
import pandas as pd
calories = {"day1": 420, "day2": 380, "day3": 390}
myvar = pd.Series(calories, index = ["day2", "day3"])
print(myvar)
‫עוד פעולות‬
DATAFRAME
.‫ הוא כל הטבלה‬DataFrame‫ הוא עמודה ו‬Series
.‫הטבלה מכילה שורות ועמודות‬
import pandas as pd
data = {
"calories": [420, 380, 390],
"duration": [50, 40, 45]
}
df = pd.DataFrame(data)
print(df)
‫גישה לעמודה מסוימת‬
‫אם נרצה לגשת לעמודה מסוימת‪ ,‬נכתוב את הפקודה הבאה‪:‬‬
‫]“‪col = df["calories‬‬
‫)‪print(col‬‬
‫גישה לשורה מסוימת ‪LOC -‬‬
‫בעזרת הפקודה ‪ loc‬נוכל לגשת לשורה מסוימת או לתא מסוים‪.‬‬
‫בצורה הבאה נוכל לגשת לשורה ה‪:0-‬‬
‫)]‪print(df.loc[0‬‬
‫שימו לב שפונקציה זו מחזירה אובייקט מסוג ‪Series‬‬
‫גישה לכמה שורות ‪LOC -‬‬
‫בצורה הבאה נוכל לגשת לשורה ה‪ 0-‬וה‪:1-‬‬
‫)]]‪print(df.loc[[0, 1‬‬
‫ברגע שנשתמש ב][ כפולים‪ ,‬הפונקציה תחזיר אובייקט מסוג ‪DataFrame‬‬
LABEL
:‫ים משלנו‬label ‫ אפשר לתת‬DataFrame‫גם ב‬
import pandas as pd
data = {
"calories": [420, 380, 390],
"duration": [50, 40, 45]
}
df = pd.DataFrame(data, index = ["day1", "day2", "day3"])
print(df)
‫‪LOC‬‬
‫לאחר שינוי ה‪label‬ים‪ ,‬נוכל לגשת לשורה בעזרת ה‪ label‬החדש‪:‬‬
‫)]"‪print(df.loc["day2‬‬
‫קריאת קובץ ‪CSV‬‬
‫דרך פשוטה לאחסן קבצי נתונים גדולים היא להשתמש בקבצי ‪) CSV‬קבצים המופרדים‬
‫בפסיקים(‪ .‬קבצי ‪ CSV‬מכילים טקסט רגיל והוא פורמט ידוע שניתן לקרוא על ידי כל‬
‫התוכנות והשפות כולל ‪ .pandas‬בעזרת הפקודה ‪ read_csv‬נוכל לקרוא טבלה‪:‬‬
‫‪import pandas as pd‬‬

‫)'‪df = pd.read_csv('data.csv‬‬
‫)‪print(df‬‬
‫)‪PRINT(DF‬‬
‫הדפסה של טבלה נותנת באופן דיפולטיבי‬
‫את חמשת השורות הראשונות‬
‫ואת חמשת השורות האחרונות‬

‫)‪DF.HEAD(10‬‬
‫אחת השיטות הנפוצות ביותר להשגת סקירה מהירה על ה‪ ,DataFrame -‬היא‬
‫פונ' )(‪ .head‬פונ' )(‪ head‬מחזירה את הכותרות ומספר שורות שצוין‪ ,‬החל‬
‫מלמעלה‪ .‬אם נשאיר את הסוגריים ריקות‪ ,‬יוחזרו ‪ 5‬השורות הראשונות‬

‫))‪print(df.head(10‬‬
DF.HEAD(10)
‫)(‪TAIL‬‬
‫יש גם את פונ' )(‪ tail‬לצפייה בשורות האחרונות של ‪ .DataFrame‬פונ' )(‪ tail‬מחזירה את הכותרות‬
‫ומספר שורות שצוין‪ ,‬החל מלמטה‪.‬‬
‫))(‪print(df.tail‬‬
‫‪TO_STRING‬‬
‫דרך נוספת להציג את הטבלה כולה‪ ,‬היא להפוך אותה מאוביקט מסוג ‪ DataFrame‬לאוביקט מסוג‬
‫‪ string‬ואז להדפיס אותה‪ .‬בצורה הבאה‪:‬‬
‫))(‪print(df.to_string‬‬
‫)(‪DF.INFO‬‬
‫לאובייקט ‪ DataFrames‬יש שיטה הנקראת )(‪ ,info‬המספקת מידע נוסף על מערך הנתונים‪.‬‬
‫))(‪print(df.info‬‬
‫‪DATA CLEANING‬‬
‫ניקוי נתונים פירושו תיקון נתונים גרועים בטבלת הנתונים‪.‬‬
‫נתונים גרועים יכולים להיות‪:‬‬
‫• תאים ריקים‬
‫• נתונים בפורמט שגוי‬
‫• מידע שגוי‬
‫• כפילויות‬
‫בטבלה ניתן לראות‪:‬‬
‫‪ .1‬ערכים ריקים )שורות ‪ 22 ,18‬ו‪(28‬‬
‫‪ .2‬ערכים שגויים )שורות ‪ 7‬ו‪(26‬‬
‫‪ .3‬שורות כפולות )שורות ‪ 11‬ו‪(12‬‬
‫מחיקת שורות‬
‫אחת הדרכים להתמודד עם תאים ריקים היא להסיר שורות המכילות תאים ריקים‪.‬‬
‫זה בדרך כלל בסדר‪ ,‬מכיוון שמערכי הנתונים יכולים להיות גדולים מאוד‪ ,‬והסרה של כמה‬
‫שורות לא תשפיע מאוד על התוצאה‪.‬‬

‫)(‪new_df = df.dropna‬‬
‫))(‪print(new_df.to_string‬‬
‫)(‪DROPNA‬‬
‫באופן דיפולטיבי‪ dropna() ,‬מחזירה טבלה חדשה‪ ,‬כמו שראינו בדוגמה הקודמת‪ .‬הטבלה‬
‫המקורית לא משתנה‪.‬‬
‫אם נרצה לשנות את הטבלה המקורית‪ ,‬נשתמש בפקודה‪inplace = True :‬‬

‫)‪df.dropna(inplace = True‬‬
‫))(‪print(df.to_string‬‬
‫החלפת תאים ריקים‬
‫דרך נוספת להתמודד עם תאים ריקים היא להוסיף במקום ערך חדש‪.‬‬
‫בדרך זו אינך צריך למחוק שורות שלמות רק בגלל כמה תאים ריקים‪.‬‬
‫שיטת )(‪ fillna‬מאפשרת לנו להחליף תאים ריקים בערך‪.‬‬

‫)‪df.fillna(130, inplace = True‬‬
‫החלפת תאים ריקים‬
‫הדוגמה שלמעלה מחליפה את כל התאים הריקים בכל הטבלה‪.‬‬
‫כדי להחליף רק ערכים ריקים בעמודה אחת‪ ,‬אפשר להוסיף את שם העמודה‪:‬‬
‫)‪df["Calories"].fillna(130, inplace = True‬‬

‫החלפת ערכים ריקים בממוצע‬
‫דרך נפוצה להחליף תאים ריקים‪ ,‬היא חישוב הערך הממוצע‪ ,‬החציוני או הערך הנפוץ של העמודה‪.‬‬
‫‪ Pandas‬מאפשר שימוש ב)(‪ median() ,mean‬ו)(‪ mode‬כדי לחשב את הערכים המתאימים‬

‫לעמודה מסוימת‪:‬‬

‫)(‪x = df["Calories"].mean‬‬
‫)‪df["Calories"].fillna(x, inplace = True‬‬
‫החלפת ערכים ריקים בחציון‬
.‫ לאחר שמיינת את כל הערכים העולים‬,‫חציון = הערך האמצעי‬
import pandas as pd
df = pd.read_csv('data.csv')
x = df["Calories"].median()
df["Calories"].fillna(x, inplace = True)
MODE‫החלפת ערכים ריקים ב‬
‫הכי פחות פעמים‬/‫ = הערך שמופיע הכי הרבה פעמים‬mode
import pandas as pd
x = df["Calories"].mode()[0]
df["Calories"].fillna(x, inplace = True)
‫נתונים בפורמט לא נכון‬
‫תאים עם נתונים בפורמט שגוי יכולים להקשות או אפילו להפוך לבלתי אפשרי את ניתוח הנתונים‪.‬‬
‫כדי לתקן את זה‪ ,‬יש שתי אפשרויות‪ :‬להסיר את השורות‪ ,‬או להמיר את כל התאים בעמודות לאותו‬
‫פורמט‪.‬‬
TO_DATETIME()
‫ נוכל להמיר את כל התאריכים לפורמט הנכון‬to_datetime() '‫בעזרת שימוש בפונ‬
import pandas as pd
df['Date'] = pd.to_datetime(df['Date'])
print(df.to_string())
‫נתונים שגויים‬
‫"נתונים שגויים" לא חייבים להיות "תאים ריקים" או "פורמט שגוי"‪ ,‬הם יכולים פשוט להיות‬
‫שגויים‪ ,‬כמו אם מישהו רשם "‪ "199‬במקום "‪."1.99‬‬
‫לפעמים אפשר לזהות נתונים שגויים על ידי הסתכלות על מערך הנתונים‪ ,‬כי יש לך ציפייה למה זה‬
‫צריך להיות‪.‬‬
‫בדוגמה שלנו‪ ,‬אפשר לראות שבשורה ‪ 7‬משך הזמן הוא ‪ ,450‬אך עבור כל שאר השורות משך‬
‫הזמן נע בין ‪ 30‬ל ‪ .60-‬זה לא חייב להיות שגוי‪ ,‬אבל אם לוקחים בחשבון שזה מערך הנתונים של‬
‫אימונים של מישהו‪ ,‬אנו מסכמים עם העובדה שאדם זה לא התאמן במשך ‪ 450‬דקות‪.‬‬
‫תיקון נתונים‬
‫אחת הדרכים לתקן ערכים שגויים היא להחליף אותם במשהו אחר‪.‬‬
‫בדוגמה שלנו‪ ,‬ככל הנראה מדובר בהקלדת שגיאה‪ ,‬והערך צריך להיות "‪ "45‬במקום‬
‫"‪ ,"450‬ונוכל פשוט להוסיף "‪ "45‬בשורה ‪:7‬‬
‫‪df.loc[7, 'Duration'] = 45‬‬
‫או להשתמש ב‪ replace‬ולהחליף את כל הערכים בערכים אחרים‪:‬‬
‫)‪df.replace(450, 45, inplace = True‬‬

‫עבור טבלאות נתונים קטנות ייתכן שאפשר להחליף את הנתונים הלא נכונים בזה אחר‬
‫זה‪ ,‬אך לא לטבלאות נתונים גדולות‪.‬‬
‫כדי להחליף נתונים שגויים עבור מערכי נתונים גדולים יותר אפשר ליצור כמה כללים‪.‬‬
‫למשל‪ ,‬להגדיר גבולות מסוימים לערכים ולהחליף את כל הערכים הנמצאים מחוץ לגבולות‪.‬‬
‫‪for x in df.index:‬‬
‫‪if df.loc[x, "Duration"] > 120:‬‬
‫‪df.loc[x, "Duration"] = 120‬‬
‫דרך נוספת לטיפול בנתונים שגויים היא להסיר את השורות המכילות נתונים שגויים‪.‬‬
‫בדרך זו לא צריך לברר במה להחליף אותם‪ ,‬ויש סיכוי טוב שאיננו זקוקים להם לביצוע‬
‫הניתוחים שלך‪.‬‬
‫‪for x in df.index:‬‬
‫‪if df.loc[x, "Duration"] > 120:‬‬
‫)‪df.drop(x, inplace = True‬‬
‫שורות כפולות‬
DROP_DUPLICATES()
drop_duplicates()‫כדי למחוק שורות כפולות נשתמש ב‬
df.drop_duplicates(inplace = True)
‫שינוי של שם עמודה‬
‫מציאת קשרים‬
‫פונ' חשובה של המודול הזה היא הפונ' )(‪ .corr‬הפונ' )(‪ corr‬מחשבת את הקשר בין כל‬
‫עמודה בערכת הנתונים שלך‪.‬‬
‫)(‪df.corr‬‬

פייתון

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

פייתון

Uploaded by

Copyright:

Available Formats

‫רות בורנשטין‬

‫שיעור ‪ :1‬מבוא‪ ,‬משתנים ואופרטורים‬ ‫‪rutbor@edu.hac.ac.il‬‬

‫דבר זה בא לידי ביטוי בשם השפה –‬

‫אשר נבחר כמחווה לקבוצה הקומית "מונטי פייתון"‪.‬‬

‫ביטוי של תוכניות מורכבות בדרך קצרה וברורה‪.‬‬

‫פייתון היא שפה מרובת־פרדיגמות‪ ,‬המאפשרת תכנות מונחה‪-‬עצמים‪ ,‬תכנות‬

‫פרוצדורלי‪ ,‬ובמידה מסוימת גם תכנות פונקציונלי‪.‬‬

‫• פייתון פשוטה בהרבה ללימוד‪ ,‬לקריאה ולכתיבה משפות אחרות‪.‬‬

‫סיבוכים מיותרים שקיימים בשפות אחרות‪.‬‬

‫ומחרוזות וספריות לפונקציות מתמטיות‪.‬‬

‫המבנה של בלוקי קוד בתוכנית נקבע על ידי ההזחה שלהם‪:‬‬ ‫‪‬‬

‫תנאים בפקודות תנאי ולולאות נכתבים ללא סוגריים‪,‬‬ ‫‪‬‬

‫לכתוב תוכנות מורכבות‪.‬‬

‫לכן‪ ,‬פיתחו את שפות התכנות העיליות‪ ,‬המאפשרות כתיבה במילים ובתחביר‬

‫כשהנפוצות הן ‪ ,c++‬ג'אווה ופייתון‪.‬‬

‫המריץ‪ ,‬ראשית יש לתרגמה לשפה זו‪.‬‬

‫שנוצר‪ ,‬מבוצע ישירות על המעבד‪.‬‬

‫תרגום זה מבוצע על ידי מהדר )‪(Compiler‬‬

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

‫בשפת מכונה והוא מבוצע מיד‪.‬‬

‫המנגנון האחראי לתרגום מקומי וביצוע מידי הוא המפרש )‪.(Interpreter‬‬

‫סביבת העבודה של פייתון מגיעה עם מפרש )‪ (Interpreter‬שמאפשר כתיבה ישירה של‬

‫בצורה כזו מאוד נוח להתנסות בשפה‪,‬‬

‫ההפעלה המותקנת עליה‪ .‬כלומר במידה והידרנו תכנית מסוימת באמצעות‬

‫מהדר המותאם למכונה מסוימת‪ ,‬התוכנית תרוץ על מכונה זו בלבד‪ .‬מפרש‪,‬‬

‫תתורגם על כל מכונה מחדש‪.‬‬

‫מתורגמת כל פעם מחדש‪ .‬בנוסף‪ ,‬דרישות מסוימות של התוכנית )כמו הקצאת‬

‫לא עובדת ישירות מול מערכת ההפעלה‪ ,‬אלא מול המפרש‪.‬‬

‫האינטרנט‪ ,‬שם יש צורך בגמישות רבה‪.‬‬

‫נמוכה והם ישמרו בסיומת ‪.pyc‬‬

‫לאחר סיום שלב זה‪ ,‬המפרש יריץ את קוד הביניים‪.‬‬

‫ואפשר לכתוב תוכניות ארוכות בכתבן )‪(editor‬‬

‫גרסת ‪ 3.0‬יצאה ב‪ 2008‬ומאז כבר יצאו הרבה מהדורות‬

‫סוגי הערכים הקיימים בפייתון הם‪:‬‬

‫‪ .1‬מספר שלם ‪ 1,2,13 – int‬וכו'‬

‫‪ .2‬מספר עשרוני ‪ 3.14 ,0.5 – float‬וכו'‬

‫‪ .3‬מחרוזת ‪“hello world” - str‬‬

‫”‪>>>name=“Sharon‬‬ ‫משתנה הוא שם המתייחס לערך‪.‬‬

‫>’‪<class ‘str‬‬ ‫יצירת משתנה בפייתון היא פשוטה‬

‫>’‪<class ‘int‬‬ ‫ואת הערך השייך לו‪.‬‬

‫)‪>>>type(other_num‬‬ ‫בפייתון אין צורך להצהיר על‬

‫ניתן לעשות השמה לכמה פרמטרים באופן הבא‪:‬‬

:‫השמה מרובה לערך יחיד אפשר לעשות באופן הבא‬

‫• שם משתנה יכול להכיל רק אותיות אנגליות )גדולות או קטנות( או‬

‫• שם משתנה אינו יכול להתחיל בספרה‪.‬‬

‫• נהוג להשתמש באותיות קטנות באנגלית לשמות משתנים‪ ,‬להשתמש‬

‫• אם מנסים להשתמש בשם לא חוקי עבור משתנה‪ ,‬מתקבלת הודעת‬

.‫ בהן אסור להשתמש כשמות משתנים‬,‫ מילים שמורות בפייתון‬33 ‫ישנן‬

:‫מלים אלו הן‬

‫אופרטורים הם סמלים מיוחדים‪ ,‬שמסמלים חישובים פשוטים‬

‫כדוגמת חיבור וכפל‪.‬‬

‫סדר הפעולות בפייתון דומה לסדר הקדימויות המתמטי הרגיל‪:‬‬

‫קודם כל סוגריים‪ ,‬לאחר‪-‬מכן חזקה‪ ,‬כפל וחילוק‪ ,‬חיבור וחיסור‪.‬‬

‫החישוב מתבצע משמאל לימין‪.‬‬

‫דוגמה‬ ‫משמעות‬ ‫אופרטור‬

‫דוגמה‬ ‫דוגמה‬ ‫אופרטור‬

‫דוגמה‬ ‫משמעות‬ ‫אופרטור‬

‫שימו לב שפונקציית ה‪ print‬מוסיפה באופן‬

‫אם נרצה לשנות זאת‪ ,‬לדוגמה‪ ,‬לרווח‬

‫)' '=‪print(“hello world”, end‬‬

print(1, 2, 3, 4, sep='#', end='&')

‫ על מנת לקרוא קלט מהמשתמש‬input ‫נשתמש בפונקציה‬

name=input(“please enter your name: ”)

please enter your name: Sharon