‫"‪Str (immutable) - "hello‬‬

‫‪]1[ , * ,+‬‬ ‫חיבור‪ ,‬הכפלה ‪ ,‬החזרה של תו ספציפי‬

‫><‬ ‫האות הראשונה בכל מילה נבחנת ע"פ המספר אסקי שלה‪( .‬במידה‬
‫וזהות יעבור לאות השנייה‪ ,‬מספר אסקי של אותיות קטנות גדולת יותר)‬
‫)'‪ord('7‬‬ ‫מקבל תו בודד‪ ,‬מחזיר את הערך האסקי‬
‫)(‪Chr‬‬ ‫מקבל ערך אסקי ומחזיר את האות המתאימה‬
‫[ ‪slicing - ] :‬‬ ‫[קפיצות ‪ :‬סוף (לא כולל) ‪ :‬התחלה (כולל) ] (יוצר עותק חדש)‬
‫)(‪type‬‬ ‫סוג‬
‫)(‪len‬‬ ‫מס' התווים במחרוזת (סופר גם רווחים)‬
‫)(‪x.lower‬‬ ‫הכול אותיות קטנות‬
‫)(‪x.upper‬‬ ‫הכול אותיות גדולות‬
‫)(‪x.title‬‬ ‫אות ראשונה בתחילת כל מילה גדולה‬
‫)'‪x.count('o‬‬ ‫כמה פעמיים מופיעה האות‬
‫)'‪x.startswith('o‬‬ ‫מחזיר ‪ True‬אם מתחיל באות שבסוגריים‬
‫)'‪x.endswith('o‬‬ ‫מחזיר ‪ True‬אם מסתיים באות שבסוגריים‬
‫)'‪x.replace('old', 'new‬‬ ‫החלפה של תווים‬
‫)'‪x.split(',‬‬ ‫מחזיר רשימה מפוצלת (ברירת מחדל רווחים) (לא לשים כלום ב() )‪.‬‬
‫‪x.strip() /‬‬ ‫מסיר תווים לא רצויים משני צידי ‪ – str‬נעצר כשנשבר הרצף (ברירת‬
‫)'‪x.strip('cscdsd‬‬ ‫מחדל רווחים)‬
‫)(‪x.rstrip() x.lstrip‬‬
‫)(‪format‬‬ ‫יצירת תבנית להכנה אוטמטית של ‪str‬‬
‫ניתן גם במקום‪:‬‬ ‫)‪"my name {}".format(name‬‬
‫}‪f"dfsf{name‬‬
‫)'‪x.Index('o‬‬ ‫נותן ערך מחזיר מיקום‬
‫)(‪.isalpha‬‬ ‫מחזיר ‪ True‬אם כל התווים אותיות‬
‫)(‪.isdigit‬‬ ‫מחזיר ‪ True‬אם כל התווים מספרים‬
‫)(‪.isupper()/islower‬‬ ‫מחזיר ‪ True‬אם כל התווים אותיות קטנות‪ /‬גדולות‬
‫(‪", ".join‬‬ ‫גורם לרשימה של ‪ ,str‬להפוך רק ל‪ str‬מופרד ב ‪,‬‬
 ‫]‪list (mutable) – [1, 2, "hi", 3.14‬‬
‫‪x[1] = 4‬‬ ‫ניתן לעדכן את הרשימה ‪ -‬תוך שימוש בהשמה (מיקום וערך)‬
‫(עדכון בלולאה ללא המיקום (הכפלה כל האיברים) לא ישאר בקביעות!)‬
‫‪*,+‬‬ ‫חיבור‪ ,‬הכפלה (בתוך הרשימה)‬
‫‪[x] * n‬‬ ‫יצירת רשימה חדשה שמורכת מ‪ n‬רשימות‬
‫[ ‪slicing - ] :‬‬ ‫[קפיצות ‪ :‬סוף (לא כולל) ‪ :‬התחלה (כולל) ] (יוצר עותק חדש)‬
‫)*‪range(len(x)/ (1,11)/ 10 I step‬‬ ‫סופר את כל המספרים מ – ‪ 0‬לא כולל הספרה שכתובה‪.‬‬
‫(ניתן לעשות קפיצות)‬
‫)(‪x.append‬‬ ‫מוסיף לסוף הרשימה ‪ -‬משנה את המקורית‬
‫)(‪x.remove‬‬ ‫מסיר את ההופעה הראשונה של האיבר ‪ -‬משנה את המקורית‬
‫)(‪x.count‬‬ ‫סופר מספר מופעים ברשימה‬
‫)'‪x.insert(2, 'hi‬‬ ‫מחדיר איבר במיקום ספציפי‬
‫)‪len(lst‬‬ ‫מספר האיברים ברשימה‬
‫)‪Sum(lst)/min(lst)/max(lst‬‬ ‫עבור רשימת מספרים‬
‫)(‪x.Index‬‬ ‫נותן ערך מחזיר מיקום‬
‫)(‪x.reverse‬‬ ‫מחזיר את הרשימה הפוך‬
‫)‪x.pop(2‬‬ ‫מוחק את האלמנט במיקום הנבחר ברשימה המקורית‪ ,‬ומחזיר את‬
‫ערכו‪.‬‬
‫(במידה ולא רושמים מיקום – מוחק כדיפולט את האיבר האחרון‪).‬‬
‫)‪sorted(x, key=len‬‬ ‫מיון הרשימה כעותק‬
‫)‪x.sort(key=lambda‬‬ ‫מיון הרשימה המקורית‬
‫‪key = len/min,max/str.upper.lower/sum/abs/str/dict.get‬‬
‫‪x.extend‬‬ ‫הוספה של ‪ str/lst‬בסוף (כמו חיבור) לרשימה ‪.x‬‬
‫(מקלף את הסוגרים הכי חיצונים‪ ,‬משנה את המקורית)‬
‫)‪If Isinstance(object, type‬‬ ‫בודק אם האיבר הוא מהסוג שביקשתי‬
‫))‪If Isinstance(object, (float, int‬‬ ‫(במידה ורוצים כמה ‪ type‬נעשה עוד ‪ isinstance‬ובאמצע ‪or‬‬
‫(‪", ".join‬‬ ‫גורם לרשימה של ‪ ,str‬להפוך רק ל‪ str‬מופרד ב ‪( ,‬למשל רשימת‬
‫מפתחות)‬

‫הדיפולט של ‪ REVERSE‬הוא ‪ FALUSE‬כלומר ממיינת מהקטן לגדול (סדר עולה)‬

‫‪ True‬ממיין מהגדול לקטן (סדר יורד)‬

‫)‪enumerate(lst‬‬
‫‪kepel = lambda x,y: x*y‬‬
‫)‪kepel(2,5‬‬
‫) ‪x = filter(lambada ==0 , lst‬‬
‫)‪List(x‬‬
‫)‪x = map(lambada==0 , lst‬‬
‫)‪List(x‬‬
‫)‪x = zip(lst1, lst2‬‬
‫‪functions‬‬
‫מקבלת רשימה ומחזירה כ‪ tuple‬אינדקס וערך‬
‫(ניתן לקבל בנפרד אם נגדיר בלולאה ‪)I,elem‬‬
‫מאפשרת ליצור פונקציה קצרה – נותן תשובה אחת‬
‫מקבלת פונקציה ורשימה ומחזירה רשימה חדשה המכילה פרטים‬
‫שהפונקציה מעריכה עבורם ‪.True‬‬
‫יש צורך להפוך את ‪ x‬לאחר מכן לרשימה ואז נקבל‪.‬‬
‫מקבלת פונקציה ורשימה – עושה את פעולת הפונקציה על כל איבר‬
‫ברשימה‬
‫יש צורך להפוך את ‪ x‬לאחר מכן לרשימה ואז נקבל‪.‬‬
‫מאחד את האיברים שנמצאים באותו מקום משתי רשימות ל ‪tuple‬‬
‫יש צורך להפוך את ‪ x‬לאחר מכן לרשימה ואז נקבל‪.‬‬
‫(אם יש רשימות לא באותו גודל – הקטן קובע)‬
 ‫)‪Tuple(immutable) – (1, 2‬‬
‫שינוי איבר‬ ‫הפיכת ל‪ ,list-‬ביצוע השמה‪ ,‬החזרה ל‪.tuple-‬‬
‫(דרך ישירה ‪)erro‬‬
‫) ‪x=(1,‬‬ ‫יצירת ‪tuple‬‬
‫‪len/max/min/in‬‬ ‫פונקציות בסיסיות‬
‫[ ‪slicing - ] :‬‬ ‫[קפיצות ‪ :‬סוף (לא כולל) ‪ :‬התחלה (כולל) ] (יוצר עותק חדש)‬
‫)‪del(x‬‬ ‫ניתן למחוק ‪tuple‬‬
‫‪+‬‬ ‫יוצר ‪ tuple‬משותף שהוא שירשור‬
‫}‪dic (mutable) – {key1: val1, key2: val2‬‬
‫אוסף שאינו מסודר‪ ,‬ניתן לשינוי וממוספר‪.‬‬ ‫•‬
‫מפתחות לא ניתנים לשינוי ! (לכן רשימה לא יכולה להיות מפתח – ניתן להיעזר ב‪)tuple‬‬ ‫•‬
‫לא ניתן למחוק‪ /‬לשנות איברים מהמילון בלולאה – יש להעביר לרשימה קודם‬ ‫•‬
‫)])‪Dict([('series', 137), ('bogi', 132‬‬ ‫יצירת מילון מ‪tuple‬‬
‫)(‪len‬‬ ‫מוגדר לכמות המפתחות במילון‬
‫)‪Sorted(dic.value() , key=grades.get/ lambda x: x‬‬ ‫יצירת רשימה ממוינת של המפתחות!!!‪.‬‬
‫)‪, reverse = True‬‬ ‫(במידה ולא מגדירים ‪ key‬הדיפוולט הוא מפתחות)‪.‬‬
‫ניתן לעשות ‪reverse‬‬
‫= ‪key‬‬
‫‪ -True‬מהגדול לקטן‬
‫‪len/min,max/str.upper.lower/sum/abs/str/dict.get‬‬
‫‪ -Faluse‬מהקטן לגדול‬
‫‪in‬‬ ‫האם המפתח קיים או לא ‪True/Falsue‬‬
‫‪dict['or']= 100‬‬ ‫שינוי ערך במילון לפי מפתח‬
‫)(‪dict.keys‬‬ ‫יוצר רשימה של כל המפתחות‬
‫)(‪dict.values‬‬ ‫יוצר רשימה של כל הערכים‬
‫)(‪dict.items‬‬ ‫יוצר רשימה של כל המפתחות והערכים ב‪tuple‬‬
‫)‪dict.get('or', default‬‬ ‫מחזיר את הערך של המפתח‪.‬‬
‫אם הערך לא קיים בדיפולט ‪None‬‬
‫)‪dict1.update(dict2‬‬ ‫שילוב של מילונים כאשר ‪ 2dict‬הוא הדורס‪.‬‬
‫]'‪del dict['or‬‬ ‫ניתן למחוק מפתח (וערכו)‬
‫)'‪dict.pop('or‬‬ ‫מסיר את המפתח והערך‪ ,‬ומחזיר את הערך‬
‫)‪dict.pop('or', default‬‬ ‫אם האיבר לא קיים יחזיר דיפולט‬
‫‪for key in dict :‬‬ ‫קבלת מפתחות וערכים‬
‫)]‪print (key, dict[key‬‬
‫‪for key, val in dict.items():‬‬
‫)‪print (key, val‬‬
‫‪dict[key] = dict.get(key, 0)+ 1‬‬ ‫קורא למפתח‪ .‬אם קיים ערכו ‪ ,+2‬ואם לא מייצרו וערכו ‪1‬‬
‫))(‪max(dic.values‬‬ ‫החזרה של הערך הכי גדול במילון‬
‫)‪max(dic, key=dic.get‬‬ ‫החזרה של המפתח בעל הערך הכי גדול במילון‬
 ‫קבצים‬
‫עבור '‪ 'w‬אחרי שכתבנו את הקוד נרשום )‪ f.write(xxxx‬בסוף‪( .‬יש לפתוח את הקובץ בקריאה '‪'r‬‬ ‫•‬
‫כדי להדפיס)‪.‬‬
‫עבור קובץ ‪ csv‬כל עמודה מופרדת בפסיק‪.‬‬ ‫•‬
‫‪f = open("test.txt", 'r'/'w'/'a',).read‬‬ ‫פתיחה מלאה (דיפולט ‪.)r‬‬
‫‪f.close‬‬ ‫‪ – r‬קריאה‪ – w ,‬דריכה‬
‫וכתיבה מחדש‬
‫סגירה ידנית בסוף‬
‫אם הקוד והקובץ לא‬
‫פתיחת קובץ‬
‫באותה תיקייה צריך את‬
‫הדרך המלאה ‪//‬‬
‫‪with open("test.txt", 'r') as f:‬‬ ‫שימוש בסגירה אוטומטית‬
‫)(‪f.read‬‬ ‫קורא את כל הקובץ כ‪str‬‬
‫)(‪f.read().split‬‬ ‫אחד!‬
‫*יוצר רשימה של מילים‬
‫][ = ‪lines‬‬ ‫מתקבלת רשימה של‬ ‫קריאת קובץ‬
‫‪for line in f:‬‬ ‫רשימות‪.‬‬
‫כל שורה בקובץ זה רשימה‬
‫)‪lines.append(line‬‬
‫)(‪f.readlines‬‬ ‫קורא כל שורה כמחרוזת‬
‫)'‪x.split(',‬‬ ‫מחזיר רשימה מפוצלת‬
‫(ברירת מחדל רווחים)‬
‫‪txt.split('\n') – rows‬‬
‫)'‪x.strip() / x.strip('cscdsd‬‬ ‫מסיר תווים לא רצויים‬
‫)(‪x.rstrip() x.lstrip‬‬ ‫משני צידי ‪ – str‬נעצר‬
‫כשנשבר הרצף (ברירת‬ ‫פונקציות ונראות‬
‫מחדל רווחים)‬
‫"‪"\n‬‬ ‫הורדת שורה (למרות ששתי‬
‫תווים התייחסות כאחד)‬
‫"‪"\t‬‬ ‫‪( Tab‬למרות ששתי תווים‬
‫התייחסות כאחד)‬
 ‫‪OOP – attributes & method‬‬
‫יצירת שדות ואתחולם‬

‫‪def _init_(self, x, y):‬‬ ‫תמיד פותחים איתה (גם למחלקה ריקה)‪,‬‬

‫נכתוב בתוכה את השדות ונאתחל‬
‫אותם‪.‬‬
‫אין לה ‪ – return‬מחזיר את‬ ‫•‬
‫האובקייט עצמו‪( .‬כתובת בזיכרון)‪.‬‬ ‫יצירת שדות‬
‫הבדיקות שמבצע הם עבור ‪-‬‬ ‫•‬ ‫ואתחולם‬
‫הארגומנטים שמקבל ‪ X,Y‬ורק אם‬
‫הם קורים מקבל ‪self.x , self.y‬‬
‫עבור שאר המטודות משתמש‬
‫תמיד ב‪self‬‬
‫‪def _init_(self, owner, suit):‬‬ ‫כאשר משתמש באותם השדות לתת‬ ‫שימוש‬
‫)‪super()._init_(owner, suit‬‬ ‫מחלקה‪ Super .‬מגיע בהתחלה ובתוך‬ ‫בשדות‪/‬‬
‫ה‪ init‬רושם את השדות הקודמים ללא‬ ‫מתודות‬
‫‪self.‬‬ ‫שיצרתי כבר‬

‫ייצוג אובייקט כמחרוזת‬

‫‪def _repr_(self):‬‬ ‫במידה ולא נכתוב תפעל דיפולטיבית לפי שם מחלקה‬
‫)‪return "{}, {}".format(self.x, self.y‬‬ ‫וכתובת הזיכרון (לא קריא)‪ .‬כתיבה שלה נותנת את‬
‫האפשרות של הייצוג הטקסטואלי‪ .‬פועל כאשר משתמשים‬
‫במתודת ‪ .str/ print‬המתודה מחזירה – מחרוזת ‪str‬‬
‫‪def _str_(self):‬‬ ‫קיימת גם בצורה דיפולטיבית‪ .‬בדומה ל ‪ repr‬אחראי על‬
‫הייצוג "היפה" ו"הקריא" של האובייקט‪.‬‬
‫(אם שתיהם כתובות הוא יעדיף את זאת)‬
‫אופרטורים מתמטיים‬
‫‪If isinstance (other, int):‬‬ ‫***ניתן לעשות הרחבה לכל מתודה ולבדוק שהמשתנה‬
‫‪Return‬‬ ‫‪ other‬הוא אכן אופרטור מתמטי לפני כדי שלא יהיה ‪erro‬‬
‫‪def Is_valid (self):‬‬ ‫כאשר רוצה לוודא שהארגומנטים תקינים‪:‬‬
‫נרשום כמתודה נפרדת מתחת ל‪ ,init‬ובתוכו תנאים‬
‫לקבלת ‪ True‬ו‪ . Faulse‬לאחר מכן נכניס תנאי ב‪:init‬‬
‫‪if not self.is_valid():‬‬
‫)" "(‪print‬‬
‫הגדרה ממש של הסימנים המתמטיים ולאחר מכן ניתן להשתמש בהם‪.‬‬
‫‪def _eq_(self, other):‬‬ ‫בצורה דיפולטיבית ההשוואה היא לכתובת בזיכרון‬
‫‪a==b‬‬ ‫ההשוואה‬ ‫שכמובן שהיא שונה‪ .‬כתיבה מניבה בחירה של‬
‫כרצוננו‪.‬‬
‫‪def _lt_(self, other):‬‬
‫‪a<b‬‬
‫ניתן להגדיר רק אחד מהם‬
‫‪def _gt_(self, other):‬‬
‫‪a>b‬‬
‫‪def _le_(self, other):‬‬
‫𝑏≤𝑎‬
‫‪def _ge_(self, other):‬‬
‫𝑏≥𝑎‬
‫‪def _add_(self, other):‬‬
‫‪c+a‬‬
‫‪def _neg_(self):‬‬
‫‪-c‬‬
‫‪def _sub_(self, other):‬‬
‫‪c-a‬‬
‫‪def _mul_(self, other):‬‬
‫‪c*a‬‬
‫‪def _truediv_(self, other):‬‬
‫‪c/a‬‬
‫‪def _floordiv_(self, other):‬‬
‫‪c//a‬‬
‫‪def _radd_(self, other):‬‬ ‫בנוסף ל ‪* - +‬‬
‫משמש כאשר הביטוי שרוצה לעשות את הפעולה הוא‬
‫בצד שמאל ולא ימים‬
 ‫הערות‪:‬‬
‫‪ – Init‬תמיד יחזיר לי את ‪ ,self‬גם אם הכנסתי ערכים לא תקינים‪( .‬יחזיר כתובת בזיכרון או טסקט אם הוגדר ‪.)repr‬‬ ‫•‬
‫חוץ עבור ‪ init‬שאר המטודות מקבלות ‪.self.x‬‬ ‫•‬
‫כאשר עובר לסעיף חדש‬ ‫•‬
‫(למשל ‪ (repr‬לא אמור לבוצע שום שינוי על סעיפים שסיימת כבר‪.‬‬
‫כאשר משתמש במטודה שיצרתי בבניה של מטודה אחרת – נשתמש במטודה תוך כדי הצבת הסוגרים ()‬ ‫•‬

‫מתודה – )(‪x.calc‬‬
‫פונקציה – )‪cala_per(x‬‬
 ‫]‪Numpy – array & | ~ [row, col‬‬
‫‪Import numpy as np‬‬
‫)] ‪a = np.array([, ,‬‬ ‫הבנאי מקבל רשימה והופך אותה למערך (ווקטור‪ ,‬מטריצה)‪.‬‬
‫)‪np.append(a, axis = 1‬‬ ‫הוספה של עמודה‪ 0( .‬שורה)‬
‫(יש צורך ביצירת משתנה חדש)‬
‫)‪np.insert(a, 0, 0‬‬ ‫החדרה של איבר במקום מסוים‬
‫(יש צורך ביצירת משתנה חדש)‬
‫‪a[1, 2] = 0‬‬ ‫הגעה לערך ושינוייו (עמודות‪ ,‬שורות)‬
‫‪11 in a‬‬ ‫אופרטור ‪In‬‬
‫)‪a.ndim / len(a‬‬ ‫מימד המערך ‪ = 3 ,2 ,1‬מס' השורות‬
‫‪a.shape‬‬ ‫ממדי המערך כ ‪( tuple‬עמודות‪ ,‬שורות)‬
‫‪a.shape[0] – row‬‬ ‫(עבור דו מימד (מס' האיברים ברשימה‪ ,‬מס' הרשימות)‬
‫‪a.shape[1] - coulmn‬‬
‫‪a.T‬‬ ‫שחלוף בין השורות לעמודות (טרנספוס)‬
‫)‪a.astype(float‬‬ ‫המרה‬
‫))‪np.vstack((a, b‬‬ ‫מוסיף את ‪ b‬מתחת ל ‪ .a‬יוצר פלט חדש‪.‬‬
‫(דרישה – מימד העמודות זהה)‬
‫))‪np.hstack((a, b‬‬ ‫מוסיף את ‪ b‬ליד ל ‪ .a‬יוצר פלט חדש‪.‬‬
‫(דרישה – מימד השורות זהה)‬
‫)‪np.zeros(7, dtype=int‬‬ ‫מחזיר את ממדי המטריצה באפסים‪.‬‬
‫)‪np.ones((2 ,3), dtype=float‬‬ ‫מחזיר את ממדי המטריצה באחדים‪.‬‬
‫)'‪np.fulll((3, 3), 'ofir‬‬ ‫מקבלת ממדי מערך ‪ +‬אובייקט ומחזירה את המטריצה שבכל מקום‬
‫האובייקט‪.‬‬
‫)‪np.eye(3‬‬ ‫יוצרת מערך דו מימדי ריבועי (מס' שורות = למס' עמודות) שעל האלכסון‬
‫הראשי יש ‪ 1‬והשאר ‪"( 0‬מטריצת היחידה")‪.‬‬
‫)‪np.diag(a‬‬ ‫מקבלת ווקטור ‪ a‬ויוצרת מערך דו מימדי כאשר הווקטור מונח על האלכסון‬
‫הראשי‪.‬‬
‫)(‪a.nonzero‬‬ ‫מחזירה את האינדקסים השונים מ‪ / 0-‬איפה שיש ‪.True‬‬
‫])(‪a[a. nonzero‬‬ ‫חילוץ המשתנים עי השמה של האינדקס‪.‬‬
‫)‪np.arange(3‬‬ ‫כמו ‪ range‬רק שיוצרת מערך‬
‫)‪np.arange(3,8‬‬
‫)‪np.arange(3,8,2‬‬
‫)‪np.linspace(2, 4, 2‬‬ ‫מקבלת ‪ start, stop, num‬ומחזירה מערך המחולק ל‪ num‬חלקים שווים‪.‬‬
‫(כולל ה‪.)stop‬‬
‫)(‪a.min‬‬ ‫מחזירה את הערך הכי קטן במערך‬
‫)(‪a.argmin‬‬ ‫מחזירה את המיקום של הערך הכי קטן במערך‬
‫)(‪a.max‬‬ ‫מחזירה את הערך הכי גדול במערך‬
‫)(‪a.argmax‬‬ ‫מחזירה את המיקום של הערך הכי גדול במערך‬
‫)‪a.mean() / np.mean(a‬‬ ‫מחזירה את ממוצע הערכים במערך‪.‬‬
‫)‪a.median / np.median(a‬‬ ‫מחזירה ערך אמצעי במטריצה‪.‬‬
‫)‪np.random.random(num‬‬ ‫מחזירה ‪ num‬איברים רנדומלים בין ‪ 0‬ל‪.1-‬‬
‫)‪np.random.random_integers(0, 20, num‬‬ ‫החזרה של ‪ int num‬בין הערכים‪.‬‬
‫))‪np.random.random_integers(0, 20, (5, 5‬‬ ‫החזרה של מטריצה רנדומלית בגודל הנתון‬
‫)(‪a.flatten‬‬ ‫משטח את המטריצה לשורה אחת‬
‫)(‪a.sum‬‬ ‫סכימה כללית‬
‫)‪a.sum(axis=0‬‬ ‫סכימה של שורות‬
‫)(‪a.all‬‬ ‫מחזיר ‪ True‬אם כל הערכים שונים מ‪ /0 -‬כל הערכים ‪.True‬‬
‫)(‪a.any‬‬ ‫מחזיר ‪ True‬אם קיים ערך כלשהוא ששונה מ‪ /0 -‬לפחות איבר אחד שהוא‬
‫‪.True‬‬
‫‪a.copy‬‬ ‫מעתיק את המטריצה‬
‫)(‪a.sort‬‬ ‫מיון כללי‬
‫)‪a.sort(axis=1‬‬ ‫מיון לפי עמודה ‪ /‬שורה‬
‫‪a+2, a-b, a*2, a/b‬‬ ‫פעולות מתמטיות בין מספרים‪ /‬מערכים‬
‫)‪np.round(formola, 3‬‬ ‫עיגול‬
‫)‪np.bincount(a‬‬ ‫מחזירה מערך המייצג את מספר ההופעות של כל אינדקס במערך‪.‬‬
‫כדי להשתמש ‪ a‬חייב להיות )(‪.flatten‬‬
‫)‪np.where(a==0‬‬ ‫מחזירה מערך חדש עם האינדקסים המקיימים את התנאי‪.‬‬
‫)‪np.where(a==0, 100, -1‬‬ ‫שינוי למי שמקיים את התנאי‪:‬‬
‫(שינוי עבור שקר‪ ,‬שינוי עבור אמת‪ ,‬התנאי)‬
‫))‪np.reshape(a, (8, 1‬‬ ‫משנה את ממדיו של המערך‪ tuple( .‬חייב להיות כפולה כלשהיא של המערך‬
‫המקורי אחרת חורג מהגבולות)‬
‫]‪mask = a[a>3‬‬ ‫מחזיר את האינדקסים של הערכים ‪ True‬שמקיימים את התנאי‪.‬‬
‫‪a[mask] = 0‬‬ ‫שינוי הערך של מה שמקיים‪.‬‬

‫‪squeezed_mat=mat[:,1::2] > 0‬‬

‫]‪im2=im[::2,::2‬‬
‫(הפסיק מפריד בין שורות לעמודות כשבתוך כל איבר אני מגדיר אם אני רוצה קפיצות)‬

‫)‪mask = np.logical_and(1+ths)*x>im>(1-ths)*x‬‬

‫הערות‪:‬‬
‫ווקטור = חד מימד‬ ‫•‬
‫מטריצה = מערך דו מימדי עם עמודות ושורות‬
‫תמונה "סלייסינג"‪.‬‬ ‫•‬
‫‪ = 0‬שורות‪ = 1 ,‬עמודות‪.‬‬ ‫•‬
‫כל איברי המערך צריכים להיות מאותו‬ ‫•‬
‫‪Pic process -‬‬ ‫הטיפוס‪.‬‬
‫‪total 256‬‬ ‫‪Import imageion‬‬ ‫עבור פונקציות אשר נראות כך ‪ np.‬יש‬ ‫•‬
‫‪Black = 0‬‬ ‫‪Import numpy as np‬‬ ‫ליצור משתנה חדש‪.‬‬
‫‪White = 255‬‬ ‫אם הופך לרשימה בסוף להחזיר‬ ‫•‬
‫"קריאה" כמו בקבצים‬ ‫למערך‪.‬‬
‫)' '(‪Im = imageio.imread‬‬
‫)(‪Im.copy‬‬ ‫יצרת עותק של המטריצה‬
‫‪w, h = img.size‬‬ ‫(שורות‪ ,‬עמודות) – בניגוד ל‪ numpy‬שהסדר שונה‪( .‬‬
‫מס' פיקלים ‪ -‬אורך כפול רוחב)‬
‫)‪Printe(im‬‬ ‫הדפסה של המטריצה‬

‫להוסיף מהאייפד‪:‬‬
‫‪Thresholding‬‬ ‫‪-‬‬
‫כיווץ‬ ‫‪-‬‬
‫טשטוש‬ ‫‪-‬‬
‫טיפול בראש‬ ‫‪-‬‬
 ‫~ | & ‪Pandas -‬‬
‫‪Import pandas as pd‬‬
‫)'‪df = pd.read_csv('path.csv‬‬ ‫פתיחת קריאה קובץ ‪excel‬‬
‫‪df.to_csv('path.csv', index=Faluse (no name‬‬ ‫כתיבה‬
‫)‪of rows 0,1,2‬‬
‫)]‪df = pd.series([3, 4, 5], index =[a, b, c‬‬ ‫הפיכה של רשימה לטבלה‬ ‫חד ממדי‬
‫)(‪df=['name'].tolist‬‬ ‫הפיכה של עמודה לרשימה‬
‫)‪df = pd.DataFrame(dic‬‬ ‫הפיכה של מילון‪numpy/‬‬
‫‪df = pd.DataFrame(np.array([[1,2,3],‬‬ ‫למאגר נתונים (טבלה)‬ ‫דו מימדי‬
‫)]'‪[4,5,6]]), column=['a', 'b', 'c‬‬
‫)(‪dic = df.to_dit‬‬ ‫הפיכה של טבלה למילון‬
‫)‪Print(df‬‬ ‫הדפסה של הטבלה‬
‫]‪df['col2'][0:2‬‬ ‫סלייסינג לעמודות‬
‫]‪df['col2'][1‬‬ ‫הגעה לערך‪ /‬תא מסוים‪.‬‬
‫]‪df[col_name][row_name‬‬ ‫‪ 1‬זה לא מיקום השורה – זה השם הדיפולטיבי שלה‬
‫‪df['avg'] = value‬‬ ‫הוספה של עמודה‬
‫)‪df['col2']=df['name'].apply(function, axis=1‬‬ ‫הוספה של עמודה לפי הפונקציה שם‪ .‬ההשמה‬
‫בצד שמאל זה העמודה שמשם לוקח את הערכים‬
‫שינוי של אותה עמודה‬
‫)‪df['col2']=df['name'].apply(function, axis=1‬‬
‫)‪df.append(value, ignore_index=True‬‬ ‫הוספה של שורה (איפה שאין ערך ירשום ‪)Nane‬‬
‫‪=pd.concat([df, pd.DataFrame([new_row])],‬‬ ‫*** ניתן גם לעשות ‪ append‬למילון עם עמודות ‪/‬‬ ‫הוספה‬
‫מפתחות מתאימות‪***.‬‬
‫‪ignore_index=True‬‬
‫)‪df['col2']=df['name'].apply(function), axis=0‬‬ ‫הוספה של שורה לפי הפונקציה ששם‪ .‬ההשמה‬
‫בצד שמאל זה העמודה שמשם לוקח את הערכים‬
‫ניתן לעשות בלי השמה ‪ applay‬וניתן ליצור גם‬
‫פונקצית עזר שאותה להציב ב‪applay‬‬
‫)‪df.drop( 'b', axis=1‬‬ ‫מוחק עמודה (ישיר או אם תנאי)‬
‫‪df.drop(['name', 'b'], axis = 1) < 60‬‬ ‫יוצר עותק אלא אם כן עושה השמה לשם המקורי‪/.‬‬
‫)‪df.drop(1 , inplace = True‬‬ ‫מוסיף את‪inplace = True :‬‬
‫)"‪row.drop("Course").drop("Registered‬‬ ‫מחיקה‬
‫]'‪df[df['country'] != 'iran‬‬ ‫מוחק שורה לפי העמודה של ‪ country‬בולינאני‬
‫)‪=df.drop([0, 14], axis =0‬‬ ‫(מחזיר את השורות שלא אירן)‬
‫מוחק שורה לפי אינדקס השורה‬
‫)'‪=pd.merge(df1, df2, on= 'key', how='inner‬‬ ‫שילוב כאשר העמודות שונות‪:‬‬
‫‪=pd.merge(df1, df2, left_on='key',‬‬ ‫מחזיר רק עמודות שלהם שורות משותפות‬
‫משותפות לפי ‪( df1‬אין ערך ‪Nane‬‬
‫)'‪how='outer‬‬
‫מחזיר הכל‪ ,‬אם לא קיים ערך ירשום ‪Nane‬‬ ‫שילוב טבלאות‬
‫‪ On‬נועד לחיבור לפי עמודה ספציפית‬
‫ב‪ key‬רושם שם של עמודה משותפת‬
‫‪=pd.concat([df1, df2], axis=0,‬‬ ‫שילוב כאשר לשניהם יש אותו עמודות – מלמטה‬
‫)‪ignore_index=True‬‬ ‫(‪ – axis=1‬מהצד)‬
‫]'‪2*df['math‬‬ ‫הכפלה של עמודה בקבוע‬
‫)(‪df.sum‬‬ ‫סכימה של כל עמודה (אלא אן כן ‪)axis‬‬
‫)(‪df.sum().sum‬‬ ‫סכימה כוללת (ערך אחד)‬
‫)(‪df.median‬‬ ‫מחזיר את המספר האמצעי‬
‫)(‪df.min() / df.max‬‬ ‫ערך מינימלי מקסימלי‬
‫פעולות מתמטיות‬
‫‪df.idxmin() /‬‬ ‫מיקום של ערך מינימלי מקסימלי‬
‫(‪df.idxmax‬‬
‫)‪df.mean(axis=1‬‬ ‫יוצר ממוצע (מתעלם אוטומטית מעמודת השמות‬
‫)(‪df.mean().mean‬‬ ‫של העמודות) אבל לא מתעלם מעמודת השמות‬
‫של השורות (צריך למחוק לפני זה ב‪.)drop‬‬
‫)‪=df.fillna(0‬‬ ‫החלפה של ערך ‪ Nane‬במשו אחר‬
‫טיפול ב‪Nane‬‬
‫)(‪=df.dropana‬‬ ‫הורדה של כל השורות עם ערך ‪Nane‬‬
‫‪df.dtypes‬‬ ‫לפי עמודות‪( .‬במידה ויש עמודה ‪ float‬אחת הכל ‪)float‬‬
‫‪df.shape‬‬ ‫מחזיר את ממדי הטבלה = (עמודות‪ ,‬שורות)‬
‫‪df.at[row, column] =10‬‬ ‫עדכון תא‬
‫אי אפשר להשתמש ב ‪inplace=True‬‬
‫)‪len(df‬‬ ‫כמות השורות‬
‫‪df['art]>85.sum() - count bool‬‬
‫‪df.index‬‬ ‫מקומי העמודות‬
‫)‪df.set_axis([list of names], axis=0/1‬‬ ‫שינוי שמות העמודות‪/‬שורות‬
‫‪df.size‬‬ ‫מס' התאים הכולל בטבלה (עמודות כפול שורות)‬
‫‪df.T‬‬ ‫טרנספוס (החלפה בין שורות לעמודות)‬
‫‪df.columns‬‬ ‫הדפסה של כל העמודות (מפתחות)‬
‫]'‪df.loc[0:7 : 'math‬‬ ‫מחזיר שורות‪/‬עמודות לפי שמות העמודות שורות כולל ‪7‬‬
‫]'‪df.loc[0/'ofir']['math‬‬
‫]‪df.iloc[:7:‬‬ ‫מחזיר שורות‪/‬עמודות לפי אינדקס שורות עמודות לא כולל ‪( 7‬סליס רגיל)‬
‫]'‪df.iloc[0, 1]['math‬‬
‫]'‪df=pd.DataFrame(a, columns=['a', 'b‬‬ ‫הגדרת שמות לעמודות‬
‫)(‪df[fails].count‬‬ ‫סופר את התאים שלא ‪Nane‬‬
‫‪artists=df['art']>85‬‬ ‫שימוש ב‪mask‬‬
‫]‪df=df[df['popilation']>1000‬‬
‫)‪print(artists‬‬
‫‪=df['math'].fillna(df['math'].mean(),‬‬ ‫חישוב הממוצע והשמה בתא חדש מבלי לפגוע‬
‫)‪inplace=True‬‬
‫)]'‪=df[df['country'].isin(['sweden', 'japan‬‬ ‫מחזיר בעמודה ‪ country‬רק את הערכים שבתוך‬
‫]'‪=df[~df.'country'.isin(['sweden', 'japan‬‬ ‫מחזיר את מה שלא‪~ .‬‬
‫‪=df.sort_values(['population'],‬‬ ‫מיון לפי ערך התאים‬
‫)‪ascending=True‬‬ ‫מיון לפי אינדקס‬
‫)(‪=df.sort)_index‬‬
‫)‪df.head(4‬‬ ‫מציג את ‪ 4‬השורות הראשונות‬
‫)‪df.tail(4‬‬ ‫מציג את ‪ 4‬השורות לפני הסוף‬
‫)‪df.sample(4‬‬ ‫מציג ‪ 4‬שורות רנדומליות‬
‫‪df.groupby(['Universe'])['bounty'].sum‬‬ ‫מחזיר טבלה המקבצת שורות דומות בעמודה לפי עמודה ספציפית‪( .‬תמיד תהיה‬
‫‪df.groupby(['Universe']).sum‬‬ ‫פעולה למשל ‪ sum‬שיקבע איך הוא מקבץ אותם)‪.‬‬
‫כללי‬
‫)(‪df.copy‬‬ ‫העתקה של הטבלה‬
‫‪df.index‬‬ ‫אינדקסים של השורות‬
‫‪for I in df.index:‬‬
‫שמות השורות בצורה דיפולטיבית הם מספרים‪( .‬לא מיקומים)‪ .‬מחיקה שורות וכו יעשה גאפ בספרות‬ ‫•‬
‫עמודות = מפתחות‬ ‫•‬
‫ה‪ type‬של טבלה זה ‪ ,DataFrame‬וה‪ type‬של עמודה‪/‬שורה בודדת זה ‪( .series‬לכל ‪ type‬פונקציות שונות)‪.‬‬ ‫•‬
‫כאשר הטבלה שלי נבנתה מ‪ numpy‬כל האובייקטים שלי מאותו הטיפוס ולכן חיבור של עמודות למשל‪ 1+ 134 :‬יתן ‪ 1341-‬ולא‬ ‫•‬
‫חיבור רגיל כי זה שרשור של ‪.str‬‬
‫חילוץ שורות === לחשוב על ‪loc iloc‬‬ ‫•‬
 ‫כללי‬
‫)(‪abs‬‬ ‫ערך מוחלט‬
‫)‪round(5.6578, 2‬‬ ‫מחזיר ‪ 2 INT‬ספרות אחרי הנקודה‬
‫)‪(num:.2f‬‬ ‫מעגל מספר ‪ 2‬ספרות אחרי הנקודה (שומר על ‪)float‬‬
‫‪//‬‬ ‫עיגול כלפי מטה‬
‫**‬ ‫חזקה‬
‫‪%‬‬ ‫שארית (מודלו)‬
‫‪for index in range(len(s)):‬‬

‫ניתן להגדיר אי שוויון כתנאי‪:‬‬ ‫•‬

‫‪If 1 ≤ 𝑚𝑜𝑛𝑡ℎ ≤ 12:‬‬
‫ל‪ 333 int‬אין‪ len‬נמיר קודם ל‪str‬‬ ‫•‬
‫•‬

‫\ ‪ -‬המשך של ‪str‬‬
‫‪- \n‬ירידת שורה‪ .‬נכנס בתוך הסוגרים‬