שפת פייתון

1. שפת פייתון טיפוסי נתונים

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

3. המילון/ טבלה • המילון מקביל ל-hash בשפות תכנות אחרות כמו למשל perl, או hashtable ב-JAVA. • מילון הוא טיפוס נתונים המכיל זוגות של נתונים: מפתח וערך, ומאפשר גישה יעילה לערכים על פי מפתחותיהם (ללא כפילויות של המפתח...).

4. דוגמה >>> d = {"server":"mpilgrim", "database":"master"} >>> d {'server': 'mpilgrim', 'database': 'master'} >>> d["server"] = 'mpilgrim' >>> d["database"] 'master' >>> d["mpilgrim"] Traceback (innermost last): File "<interactive input>", line 1, in ? KeyError: mpilgrim

5. שינוי ועדכון של מילונים • נמשיך את הדוגמה הקודמת: >>> d {'server': 'mpilgrim', 'database': 'master'} >>> d["database"] = "pubs" >>> d {'server': 'mpilgrim', 'database': 'pubs'} >>> d["uid"] = "sa" >>> d {'server': 'mpilgrim', 'uid': 'sa', 'database': 'pubs'}

6. מילונים אינם סדורים. • במילונים אין שום משמעות לסדר פנימי. לא ניתן למשל לגשת ישירות לערך בעל מספר סידורי כלשהו, שכן אין מספרים סידוריים למפתחות, גם לא לפי ערך אלפביתי. • המפתחות הינן case sensetive. • לשים לב ל-{} שמייצגות את המילון.

7. פולימורפיזם: >>> d {'server': 'mpilgrim', 'uid': 'sa', 'database': 'pubs'} >>> d["retrycount"] = 3 >>> d {'server': 'mpilgrim', 'uid': 'sa', 'database': 'master', 'retrycount': 3} >>> d[42] = "douglas" >>> d {'server': 'mpilgrim', 'uid': 'sa', 'database': 'master', 42: 'douglas', 'retrycount': 3}

8. מחיקת ערכים מתוך מילון >>> d {'server': 'mpilgrim', 'uid': 'sa', 'database': 'master', 42: 'douglas', 'retrycount': 3} >>> del d[42] >>> d {'server': 'mpilgrim', 'uid': 'sa', 'database': 'master', 'retrycount': 3} >>> d.clear() >>> d {}

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

10. הגדרת רשימה >>> li = ["a", "b", "mpilgrim", "z", "example"] >>> li ['a', 'b', 'mpilgrim', 'z', 'example'] >>> li[0] 'a' >>> li[4] 'example' • לשים לב ל-[] שמייצגות את הרשימה... • האינדקס מתחיל מ-0.

11. מספרים סידוריים שליליים >>> li ['a', 'b', 'mpilgrim', 'z', 'example'] >>> li[-1] 'example' >>> li[-3] 'mpilgrim' • li[-n]=li[len(li)-n] כאשר len(list) היא פונקציה שמורה של python שמחזירה אורך של רשימה.

12. יצירת תתי רשימות (slicing) >>> li ['a', 'b', 'mpilgrim', 'z', 'example'] >>> li[1:3] ['b', 'mpilgrim'] >>> li[1:-1] ['b', 'mpilgrim', 'z'] >>> li[0:3] ['a', 'b', 'mpilgrim']

13. קיצורים ביצירת תתי רשימות >>> li ['a', 'b', 'mpilgrim', 'z', 'example'] >>> li[:3] #from 0 until (not including) 3 ['a', 'b', 'mpilgrim'] >>> li[3:] #from 3 to the end ['z', 'example'] >>> li[:] #make a copy by value of the list ['a', 'b', 'mpilgrim', 'z', 'example']

14. קיצורים ביצירת תתי רשימותהמשך >>> li = ["a", "b", "c", "d", "E"]>>> la = li>>> la['a', 'b', 'c', 'd', 'E']>>> la[0] = 'A'>>> li['A', 'b', 'c', 'd', 'E']>>> lb = li[:]>>> lb[1] = 'A'>>> lb['A', 'A', 'c', 'd', 'E']>>> la['A', 'b', 'c', 'd', 'E']

15. הוספת אלמנטים לרשימות >>> li ['a', 'b', 'mpilgrim', 'z', 'example'] >>> li.append("new") >>> li ['a', 'b', 'mpilgrim', 'z', 'example', 'new'] >>> li.insert(2, "new") >>> li ['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new'] >>> li.extend(["two", "elements"]) >>> li ['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', 'two', 'elements']

16. חיפוש ברשימה >>> li ['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', 'two', 'elements'] >>> li.index("example") 5 >>> li.index("new") #return first appearance 2 >>> li.index("c") Traceback (innermost last): File "<interactive input>", line 1, in ? ValueError: list.index(x): x not in list >>> "c" in li #so we won’t get an exception… True

17. הסרת ערכים מתוך רשימה >>> li ['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', 'two', 'elements'] >>> li.remove("z") >>> li ['a', 'b', 'new', 'mpilgrim', 'example', 'new', 'two', 'elements'] >>> li.remove("new") >>> li ['a', 'b', 'mpilgrim', 'example', 'new', 'two', 'elements']

18. המשך דוגמה... >>> li.remove("c") Traceback (innermost last): File "<interactive input>", line 1, in ? ValueError: list.remove(x): x not in list >>> li.pop() #treat list as a stack… 'elements' >>> li ['a', 'b', 'mpilgrim', 'example', 'new', 'two']

19. אופרטורים של רשימות >>> li = ['a', 'b', 'mpilgrim'] >>> li = li + ['example', 'new'] >>> li ['a', 'b', 'mpilgrim', 'example', 'new'] >>> li += ['two'] >>> li ['a', 'b', 'mpilgrim', 'example', 'new', 'two'] >>> li = [1, 2] * 3 >>> li [1, 2, 1, 2, 1, 2]

20. רשומות – רשימות בלתי משתנות (Tuples) • ומהווה רשימה בלתי משתנה (immutable list). מרגע יצירת רשימה כזו, לא ניתן עוד לשנות את תכנה בשום צורה – אך ניתן לגשת אליו למטרת קריאה.

21.  הגדרת רשומה >>> t = ("a", "b", "mpilgrim", "z", "example") >>> t ('a', 'b', 'mpilgrim', 'z', 'example') >>> t[0] 'a' >>> t[-1] 'example' >>> t[1:3] ('b', 'mpilgrim') • לשים לב ל-() בהגדרת רשומה...

22. רשומה בעלת אלמנט יחיד תוגדר על ידי הוספת פסיק אחרי האלמנט, כדי למנוע ערפול או בלבול עם סוגריים רגילים. באופן כללי, תמיד ניתן להוסיף פסיק אחד "מיותר", גם אם יש יותר מאשר איבר אחד ברשימה או רשומה. • t = (“element”,) • לרשומות אין פונקציות...כי הם קבועות... • במקום index נשתמש ב- in... “a” in t

23.  לשם מה, אם כן, צריך בכלל רשומות? • ראשית, רשומות מהירות יותר מאשר רשימות. אם את/ה זקוק/ה לרשימה קבועה של ערכים מבלי צורך לשנותה, עדיף להשתמש ברשומות. • רשומות יכולות להיות מפתחות של מילון, בניגוד לרשימות. • רשומות משמשות ביצירת תבניות של מחרוזות, כפי שנראה בהמשך. • הערה: ניתן להפוך רשימות לרשומות ולהיפך. • הפונקציה tuple(somelist) מקבלת רשימה ומחזירה רשומה המכילה את אותם אברים. • הפונקציה list(sometuple) בהתאם מקבלת רשומה ומחזירה רשימה המכילה את אותם האיברים.

24. השמה מרובה באמצעות רשומות ורשימות • אחד מקיצורי הדרך האלגנטיים בתכנות בפייתון הוא השימוש ברצפים (רשומות ורשימות) לצורך השמת ערכים בכמה משתנים בו זמנית: >>> v = ('a', 'b', 'e') >>> (x, y, z) = v >>> x 'a' >>> y 'b' >>> z 'e' • יש לרשום משתנים ברשימה!!!

25. לפעולה האחרונה שימושים רבים. אחד מהם מקביל לזה שנעשה בשפת C במבנה ה-ENUM – הקצאת שמות לרצף של ערכים. שימוש זה נעשה אלגנטי עוד יותר בפייתון, בתוספת הפונקציה range כפי שנראה להלן: >>> range(7) #returns a range from 0 to 6 [0, 1, 2, 3, 4, 5, 6] >>> (MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY) = range(7) >>> MONDAY 0 >>> TUESDAY 1 >>> SUNDAY 6

26. הפונקציה range >>> range (6)[0, 1, 2, 3, 4, 5]>>> range(6, 12)[6, 7, 8, 9, 10, 11]>>> range(6, 12, 2)[6, 8, 10]

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

28. שימוש ברשומות בתבניות מחרוזות • כמו ב-sprintf ב-C. • יש להשתמש ב-% ולאחריו רשומה. • טוב להטמעת int או float בתוך מחרוזות (ללא שימוש בפונקציה int(a)...). Example 1: >>> k = "uid" >>> v = "sa" >>> "%s=%s" % (k, v) 'uid=sa' Example 2:

29. המשך הדוגמה >>> uid = "sa" >>> pwd = "secret" >>> print pwd + " is not a good password for " + uid secret is not a good password for sa >>> print "%s is not a good password for %s" % (pwd, uid) secret is not a good password for sa >>> userCount = 6 >>> print "Users connected: %d" % (userCount,)#1 elment Users connected: 6 >>> print "Users connected: " + userCount Traceback (innermost last): File "<interactive input>", line 1, in ? TypeError: cannot add type "int" to string

30. מיפוי רשימות • רוצים לבצע מיפוי אחד לאחד של רשימות בצורה קומפקטית ואלגנטית על ידי החלת פעולה כלשהי על כל אחד מאברי הרשימה. • נשתמש בתבנית for…in…: >>> li = [1, 9, 8, 4] >>> [elem*2 for elem in li] [2, 18, 16, 8] >>> li [1, 9, 8, 4] >>> li = [elem*2 for elem in li] >>> li [2, 18, 16, 8]

31. 3 פונקציות חדשות של טיפוס המילון • לפני שנמשיך, נחזור אחורה בזמן למילונים: >>> params = {"server":"mpilgrim", "database":"master", "uid":"sa", "pwd":"secret"} >>> params.keys() ['server', 'uid', 'database', 'pwd'] >>> params.values() ['mpilgrim', 'sa', 'master', 'secret'] >>> params.items() #return table pairs as tuples #list [('server', 'mpilgrim'), ('uid', 'sa'), ('database', 'master'), ('pwd', 'secret')]

32. דוגמה • ["%s=%s" % (k, v) for k, v in params.items()] • מה מחזיר הביטוי? Params הוא מילון. הביטוי לוקח את רשימת התוכן של המילון – params.items(), וממפה אותה לרשימה חדשה על ידי החלת תבנית המחרוזת על כל אחד מהאלמנטים (הרשומות). הרשימה החדשה תכיל את אותו מספר האלמנטים כמו הרשימה המקורית, אך במקום רשומות תופענה ברשימה החדשה מחרוזות שתכלנה את המפתח ואת הערך שהכילה הרשומה המתאימה.הפכנו את המילון לרשימת מחרוזות סדורה! • זה יהיה, אם כן, הפלט של הביטוי: • ['server=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret']

33. איחוד רשימות ופיצול מחרוזות • פונקצית join(): • בוחרים מחרוזת "מפרידה". • מפעילים את פונקצית ה-join השייכת לאובייקט המחרוזת ושולחים אליו רשימה של מחרוזות שאותם אנו חפצים להפריד ע"י המחרוזת/תו המפריד ומקבלים מחרוזת משורשרת חדשה... return ";".join(["%s=%s" % (k, v) for k, v in params.items()])

34. המשך הדוגמה >>> params = {"server":"mpilgrim", "database":"master", "uid":"sa", "pwd":"secret"} >>> ["%s=%s" % (k, v) for k, v in params.items()]['server=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret'] >>> ";".join(["%s=%s" % (k, v) for k, v in prams.items()])server=mpilgrim;uid=sa;database=master;pwd=secret

35. פונקצית split הופכית ל-join: >>> li = ['server=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret'] >>> s = ";".join(li) >>> s 'server=mpilgrim;uid=sa;database=master;pwd=secret' >>> s.split(";") #from string to seperated list… ['server=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret'] >>> s.split(";", 1) #just the first one…got a 2 element list… ['server=mpilgrim','uid=sa;database=master;pwd=secret']

36. סינון רשימות • ניתן להרחיב את יכולתה של פייתון למיפוי על ידי הכללת רשימות, ולשלב בה מנגנון סינון, בעזרתו חלק מהאברים ברשימה ממופים בעוד על חלק אחר אנו מדלגים. • תחביר של סינון רשימות: [mapping.expression for element in source.list if filter.expression]

37. סינון רשימותדוגמה >>> li = ["a", "mpilgrim", "foo", "b", "c", "b", "d", "d"] >>> [elem for elem in li if len(elem) > 1] ['mpilgrim', 'foo'] >>> [elem for elem in li if elem != "b"] ['a', 'mpilgrim', 'foo', 'c', 'd', 'd'] >>> [elem for elem in li if li.count(elem) == 1] ['a', 'mpilgrim', 'foo', 'c'] • פונקצית count שייכת לאובייקט רשימה ומחזירה את מספר הפעמים שאיבר הקלט מופיע באותה הרשימה.