מחרוזת אחת במרווח או על פני כמה שורות t \n\- נניח שאנו רוצים לכתוב מחרוזת אחת (המילה shalom שלוש פעמים ברצף) על פני כמה שורות ולא בשורה אחת על המסך, או שאנו רוצים מרווח מסוים בין חלק אחד של המחרוזת לחלקה האחר. הבה נראה איך עושים זאת – x="shalomshalomshalom" print(x) >>> shalomshalomshalom עוד אחת x="shalom\nshalom\tshalom" print(x) >>> shalom shalom shalom למעלה אנו רואים הדפסה רגילה של המחרוזת, ובתוכנית מתחתיה אנו רואים שתי אפשרויות נחמדות: האחת מעבירה אותך לשורה חדשה אם כותבים n\ ושמים לב שזה backslash שנמצא גבוה בצד ימין של המקלדת ולא slash רגיל שיש אותו בשפע)- האות n בגלל המילה new line. האותיות החל מזאת שאחרי האות n יכתבו כבר בשורה חדשה. דבר שני הוא t\ האות t מהמילה tab, כלומר מרווח בגודל קבוע, כך שהכיתוב לאחר האות t יהיה במרווח קבוע מסוים. סיכום, לקחנו שלוש מילים מחוברות, אחרי הראשונה ירדנו לשורה חדשה ואת השלישית התוכנה הדפיסה את המילה הבאה במרווח מהשנייה.

רשימה list פייתון מאפשרת ארגון מידע בצורות שונות שאחת המרכזיות בהן היא הרשימה (באנגלית list), באמצעותה למשל בנינו פעם תוכנה אולטימטיבית לפתרון סודוקו וגם תוכנות שעזרו לנו לפתור חידות. רשימה מייצרים באמצעות רישום אברי הרשימה בסוגריים מרובעים, כאשר כל איבר מופרד בפסיק (,) , אולם תחילה אנו צריכים לבחור שם לרשימה שלנו (כל זמן שהמילה אינה פקודה בשפת פייתון כמו למשל המילה list שבה אסור להשתמש) - lista=[5,8,"sababa",-3] print (lista) >>> [5, 8, 'sababa', -3] אנו רואים שהרשימה יכולה להכיל מספרים, מחרוזות גם רשימות (בתוך רשימות) וגם סוגים נוספים של מידע (סוגים שונים של אובייקטים). ברשימה יש חשיבות לסדר האיברים או הפריטים המאורגנים בתוכה וכל פריט ברשימה מקבל מספר (index), כאשר השמאלי ביותר הוא הראשון והימני ביותר הוא האחרון. האיבר הראשון ברשימה אינו איבר מספר 1 בפייתון, משום שבשפה הזאת המספור מתחיל מ....אפס, זה מבלבל לעיתים קרובות אבל יש לכך גם יתרונות שיתגלו בהמשך. לכן איבר מספר 1 ברשימה שלנו, שקראנו לה lista הוא המספר 8, ואיך אפשר לגלות את זה ? אפשר לבקש מהמחשב שידפיס את איבר מספר 1 ברשימה lista - lista=[5,8,"sababa",-3] print (lista[1]) >>> 8 lista=[5,8,"sababa",-3] print (lista[0]) >>> 5 אפשר לבקש מהמחשב שידפיס את האיברים מ- 0 עד 3 כאשר המילה "עד" נרשמת באמצעות נקודתיים (:) ובמקרה הזה התוכנה תדפיס החל מהאיבר הראשון (איבר 0) אבל לא כולל את איבר מספר 3 (שהוא הרביעי ברשימה)– זה עוד עניין מבלבל בפייתון – דוגמאות עשויות לרכך את הבלבול - lista=[5,8,"sababa",-3] print (lista[0:3]) >>> [5, 8, 'sababa'] עוד אחת lista=[5,8,"sababa",-3] print (lista[1:3]) >>> [8, 'sababa'] רישום נוסף להוראה להדפיס את איברי הרשימה מהראשון עד מספר 3 (לא כולל) היא לרשום נקודתיים (:) בלי הספרה 0 לפני. lista=[5,8,"sababa",-3] print (lista[:3]) >>> [5, 8, 'sababa'] ויש גם דרך מקוצרת לבקש הדפסה מהאיבר מספר 2 עד הסוף – lista=[5,8,"sababa",-3] print (lista[2:]) >>> ['sababa', -3] העסק בהחלט יכול להיות מבלבל בהתחלה למרות שיש הגיון מסוים שאם אתה מבקש הדפסה של איברי רשימה עד איבר 3 אתה בעצם מקבל שלושה איברים (0,1,2). הוספה והשמטה של איברים ברשימה דרך אחת להוסיף איבר לרשימה היא פקודת append - lista=[1,2,3,4] lista.append("sababa") print (lista) >>> [1, 2, 3, 4, 'sababa'] מרגע שיצרנו את הרשימה, אנו יכולים לבצע פעולות שונות באמצעות רישום שם הרשימה (lista) ולאחריה נקודה ושם הפקודה. הפקודה append מוסיפה איבר המופיע בסוגריים בסוף הרשימה בצידה הימיני. אפשר גם ככה להוסיף איבר לסוף הרשימה – lista=[1,2,3,4] lista+=["sababa"] print (lista) >>> [1, 2, 3, 4, 'sababa'] כדי להוסיף יותר מאיבר אחד לסוף הרשימה נשתמש בפקודה extend - lista=[1,2,3,4] lista.extend([5,6,7]) print (lista) >>> [1, 2, 3, 4, 5, 6 ,7] החלפה של איבר במיקום מסוים – lista=[1,2,3,4] lista[2]=9 print (lista) >>> [1, 2, 9, 4] הוספה של איבר למיקום מסוים (insert) lista=[1,2,3,4] lista.insert(2,9) print (lista) >>> [1, 2, 9, 3, 4] בתוכנית למעלה אנו הוספנו את הספרה 9 לתוך המיקום מס' 2 (המיקום השלישי ברשימה אם מתחילים מאפס) בלי להוציא את הספרה 3 מהרשימה. השמטה של האיבר האחרון ברשימה – lista=[1,2,3,4] lista.pop() print (lista) >>> [1, 2, 3] השמטה של איבר מסוים ברשימה, כלומר השמטה של הספרה 2 מהרשימה – lista=[1,2,3,4] lista.remove(2) print (lista) >>> [1, 3, 4] השמטה של איבר שמיקומו ברשימה הוא 2 (האיבר השלישי אם מתחילים לספור מ - 0) - lista=[1,2,3,4] lista.remove(lista[2]) print (lista) >>> [1, 2, 4] השמטה של האיבר השני מהסוף- lista=[1,2,3,4,5,6] lista.remove(lista[-2]) print (lista) >>> [1, 2, 3, 4, 6] אנו רואים למעלה שאפשר להתייחס למיקומים של איברים ברשימה על פי מיקומם מהסוף באמצעות מספרים שליליים. אנו יכולים לספור כמה איברים יש לנו ברשימה באמצעות הפקודה len – lista=[1,2,3,4, 7, 125, "sababa"] print (len(lista)) >>> 7 במקרה הזה יש לנו 7 איברים המסומנים בפייתון מ- 0 עד 6 מהראשון עד האחרון. ויש עוד פעולות שניתן לבצע על רשימות כמו להפוך את הסדר שלהן (reverse) לספור כמה איברים זהים יש ברשימה (count) ועוד. נתבונן בתוכנית המורכבת הבאה ונראה מה היא מבצעת – lista=[1,2,3,4] lista.remove(lista[1]) lista.pop() lista.append (8) lista.reverse() print (lista) >>> [8, 3, 1] בהתחלה הסרנו את האיבר מס' 1 שהוא הספרה 2 מהרשימה וקיבלנו 1,3,4]] . לאחר מכן הסרנו את האיבר האחרון ברשימה (הספרה 4) וקיבלנו [1,3] . לאחר מכן הוספנו את הספרה 8 לסוף הרשימה וקיבלנו [1,3,8] ולבסוף הפכנו את סדר הרשימה כדי לקבל את התוצאה הסופית אותה ביקשנו להדפיס על המסך. השימוש בפקודה index לעומת שימוש בפקודה enumerate - כאמור, כדי לדעת מיקום של איבר ברשימה אנו משתמשים בפקודה index כשהיא צמודה לשם הרשימה - lista = ["a","b","c"] print(lista.index("c")) >>> 2 אנו מקבלים שהתוצאה היא 2, אבל, העדר הבנה עמוקה של המתודה index עלולה לגרום לתקלות בתכנית, משום שהפקודה index נותנת את המיקום הראשון ברשימה, בו מופיע מה שמחפשים. כך למשל בתוכנית הבאה - lista = [1,0,1,0,1,2,1,0] print(lista.index(1)) >>> 0 אנו מקבלים שהמיקום של הספרה 0 הוא -0. למרות שהיא מופיעה במקומות נוספים ולא רק בתחילת הרשימה. אחד הפתרונות לחלק מהבעיות שצצות בהקשר הזה – הוא שימוש בפקודה enumerate המייצרת אובייקט המייצר לנו צמדים, את המיקום האמיתי ברשימה ואת התוכן של מה שנמצא באותו מיקום. lista=[1,0,1,0,1,0] for a,b in enumerate(lista): print(a,b) >>> 0 1 1 0 2 1 3 0 4 1 5 0 את התוצרים של פקודת enumerate אנו מקבלים באמצעות לולאת for ואנו רואים שאנו מקבלים צמד, מצד שמאל את המיקום האמיתי ברשימה, ובצד ימין את התוכן הקיים באותו מיקום.

טופל tuple חוץ מזה שזה אובייקט עם שם מוזר, שחלק הוגים אותו כמו טאפל (לדעתי בטעות אבל אם למישהו יש דיבור עם חידו רוסום שיעדכן בפורום), זו צורה פשוטה יותר של ארגון מידע הוא בצורה של רשימה מיוחדת הקרויה טופל. זו בעצם רשימה של איברים שההבדל בינה לבין רשימה הוא שלא ניתן לבצע ב tuple שינויים, גוף כזה מכונה בפייתון immutable. הטופל מסומן בסוגריים עגולים – tup=(1,2,3,4) print (tup) >>> (1, 2, 3, 4) אפשר להדפיס איבר אחד מתוך הטופל – tup=(1,2,3,4) print (tup[1]) >>> 2 אנו רואים שלמרות שטופל מצוין באמצעות סוגריים עגולים, עדיין כדי להדפיס חלקים ממנו אנו משתמשים בסוגרים מרובעים. כך למשל אנו יכולים לבקש להדפיס את כל הטופל מהסוף להתחלה – tup=(1,2,3,4) print (tup[::-1]) >>> (4,3,2,1) המשמעות של ([::]print(tup היא הדפס את כל האיברים בטופל מהתחלה עד הסוף, וכאשר מוספים פרמטר מספרי לאחר הנקודות אזי ההדפסה מתחילה ממיקום האיבר הנקוב בפרמטר כאשר כל פעם מצטרף איבר הגדול ב -1 מאותו פרמטר, כלומר מתחילים באיבר -1 לאחר מכן איבר -2 וכו' כך מתקדמים מהסוף להתחלה. ראוי לשים לב שאנו לא משנים את הטופל – הוא אינו בר שינוי, אנו רק משנים את סדר ההדפסה מתוך הטופל. למה צריך את זה ? לעיתים אנו רוצים להגן על מידע מפני שינוי על מנת שלא יבוצע בו בטעות שינוי שיהרוס אותו. לכן פקודות כמו pop או append אינם ישימות לטופל שכן אלה פקודות המשנות את הרשימה. אנו יכולים גם למזג שני טופלים וליצור טופל שלישי - x=(1,2,3) y=(4,5,6) z=(x+y) print(z) >>> (1, 2, 3, 4, 5, 6)

מילון dictionary מילון הוא צורה נוספת של ארגון מידע (אובייקט נוסף) ועושה שימוש בסוג נוסף של סוגריים – הפעם מסולסלים { } . במילון סדר האיברים אינו חשוב ואינו נשמר, וכל איבר מחולק לשניים מפתח key וערך value המופרדים ביניהם בנקודתיים (:) – נדגים - dicta={"a" : 1,"b" :2, "c" :3} print (dicta) >>> {'a': 1, 'b': 2, 'c': 3} והדרך לקבל ערך dicta={"a" : 1,"b" :2, "c" :3} print (dicta["b"]) >>> 2 הצורה הפשוטה לשימוש במילון היא לבקש מהמחשב להדפיס את הערך הצמוד לאחד המפתחות, במקרא שלנו למחרוזת "b" . כמו במילון, מחפשים הגדרה ומקבלים פירוש... פחות או יותר. אפשר לבקש לעדכן את המילון ולהוסיף איבר נוסף (מפתח וערך) - dicta={"a" : 1,"b" :2, "c" :3} dicta ["d"]=4 print (dicta) >>> {'a': 1, 'b': 2, 'c': 3, 'd': 4} הסרת איבר מהמילון על ידי קריאה בשם המפתח – dicta={"a" : 1,"b" :2, "c" :3} del dicta ["b"] print (dicta) >>> {'a': 1, 'c': 3} בכל מילון יכול להופיע כל מפתח פעם אחת בלבד, הערכים יכולים להופיע פעמים רבות ויכולים ללבוש צורה של אובייקטים שונים (מחרוזת, מספר, רשימה, טופל וכו'). מפתחות יכולים להיות רק אובייקט מסוג מחרוזת, מספר או טופל – כלומר צורות שלא ניתן לשנות אותן (immutable) – מפתח אינו יכול להיות רשימה משום שרשימה מוגדרת mutable object (אנו יכולים להוסיף לה איברים, למחוק ממנה איברים וכו' מה שאי אפשר עם טופל או integer או מחרוזת). כמו ברשימה, מרגע שיצרנו את המילון ניתן לבצע פעולות שונות באמצעות הקלדת שם המשתנה (השם שבחרנו לקרוא למילון המסוים) לאחריו נקודה (.) ולאחריה הפקודה. כך למשל הפקודה get תמצא את הערך הצמוד למפתח והפקודה pop תמחק מהמילון מפתח וערך מסוימים (בהתאם למפתח). dicta={"a" : 1,"b" :2, "c" :3} print(dicta.get ("a")) >>> 1 dicta={"a":1,"b":2,"c":3} dicta.pop("a") print(dicta) >>> {'b': 2, 'c': 3} אפשר לבקש להדפיס את רשימת הערכים המופיעים במילון או רשימת המפתחות המופיעים במילון – dicta={"a":1,"b":2,"c":3} print(dicta.values()) >>> dict_values([1, 2, 3]) dicta={"a":1,"b":2,"c":3} print(dicta.keys()) >>> dict_keys(['a', 'b', 'c']) dicta = {'a':1, 'b':2, 'c':3} print(dicta.items()) >>> dict_items([('a', 1), ('b', 2), ('c', 3)]) הפקודה ()dicta.items מחזירה רשימה שמכילה טופלים ובהם המפתחות והערכים של המילון. dicta = {'a':1, 'b':2, 'c':3} print(len(dicta)) >>> 3 dicta = {'a':1,'b':2} x = {'a':2, 'b':6, 'c':5} print(dicta) >>> {'a': 1, 'b': 2} dicta.update(x) print(dicta) >>> {'a': 2, 'b': 6, 'c': 5} למעלה אנו רואים דרך מהירה לעדכן מילון. החל מפייתון 3.5 ניתן למזג שני מילונים למילון אחד, כאשר מפתחות כפולים יהפכו לאחד (הערך שיכנס הוא הערך מהמילון השני) הדבר מתבצע באמצעות שתי כוכביות ושם המילון, דבר שמוציא את התוכן של המילון- x={"a":1,"b":2} y={"c":4,"d":8,"a":5} z={**x,**y} print(z) >>> {'a': 5, 'b': 2, 'c': 4, 'd': 8}

תרגיל - מילון בתרגיל זה צריך תחילה לבנות מילון בשם dicta המכיל שלושה מפתחות "a","b","c" ולכל אחד ערך מספרי מ- 1 עד 3 בהתאמה. לאחר שבניתם את המילון, אתם צריכים להוסיף מפתח נוסף "d" שהערך שלו יהיה רשימה המכילה את המספרים 7,8,9. כעת נניח שלצורך מסויים אתם צריכים לשלוף מהמילון מתוך הערך של המפתח "d" רק את המספר האמצעי ברשימה (רק את הספרה 8) כיצד אפשר לעשות זאת ? פתרון התרגיל: dicta = {"a":1,"b":2,"c":3} dicta["d"]=[7,8,9] print(dicta) >>> {'a': 1, 'b': 2, 'c': 3, 'd': [7, 8, 9]} print(dicta.get("d")[1]) >>> 8 הסבר – תחילה יצרנו מילון באמצעות בחירת משתנה dicta לתוכו ביצענו השמה של נתונים בתוך סוגריים מסולסלים, כאשר כל מפתח והערך הצמוד לו מופרדים בנקודתיים. להוסיף מפתח נוסף בשם "d" בעל ערך שהוא רשימה פשוט כותבים [dicta["d"]=[7,8,9 . בשלב זה אם מבקשים להדפיס את המילון, מקבלים גם את המפתח החדש והרשימה הצמודה אליו. כדי לקבל בחזרה רק את הספרה 8 מתוך הרשימה שהיא ערך המשוייך למפתח "d" – נשתמש במתודה ("get("d ולאחריה תוספת של [index [1 המצביע בעצם על האיבר השני ברשימה (כי האינדקס של האיבר הראשון הוא 0).

סט set אובייקט נוסף הקיים בפייתון לצורך ארגון מידע הוא set המסומן באמצעות סוגריים מסולסלים { } כאשר כל המידע המצוי בתוכו אינו כפוף לסדר מסוים ואין חשיבות למיקום בתוך הסט, לכן לא ניתן לבצע חיתוכים כמו ברשימה או לאתר מיקום של איבר בתוך הסט, כמו כן המחשב אינו מתייחס למספר הפעמים שאיבר מסוימים מופיע בסט, ומבחינתו האיבר קיים או לא קיים בלבד. הפעולות השימושיות בסטים נוגעות לצורך במניעת כפילויות של פרטי מידע, לצורך לוודא קיום או אי קיום של פרט בלי קשר לכמויות וכן להשוואה בין שני סטים ואיתור איברים חופפים (או שאינם קיימים בסט אחר). st={"a","b","c",1,2,3,"a","b",1,2,3,4,5} print(st) >>> {1, 'c', 2, 3, 4, 5, 'b', 'a'} st={"a","b","c",1,2,3,"a","b",1,2,3,4,5} print(len(st)) >>> 8 אפשר לראות למעלה שהמחשב מחשיב כל איבר בסט פעם אחת בלבד למרות שכתבנו חלק מהאיברים בסט כמה פעמים. וכאשר מבקשים ממנו לספור את כמות האיברים בסט התשובה היא 8 משום שהוא בודק כמה פריטים ייחודיים ישנם ולא כמה סך הכל. אפשר להוסיף ולהוציא פריטים מסוימים בתוך הסט – st={"a","b","c",1,2,3} st.remove("b") # st.discard(b) אפשר גם st.add("e") print (st) >>> {1, 2, 3, 'e', 'c', 'a'} אפשר לאתר חפיפה בין שני סטים – st1={"a","b","c","d","e"} st2={"a","b",1,2,3,4} print(st1.intersection(st2)) >>> {'b', 'a'} אפשר למצוא חלקים בסט אחד שאינם מופיעים בסט השני - st1={"a","b","c","d","e"} st2={"a","b",1,2,3,4} print(st1.difference(st2)) >>> {'c', 'e', 'd'} אפשר למצוא את האיחוד של כל הפריטים משני הסטים (בלי לקחת בחשבון פריט אחד פעמיים) - set1={1,2,3,"banana",5,6,7} set2={1,2,3} print(set1.union(set2)) >>> {'banana', 1, 2, 3, 5, 6, 7} על מנת לייצר סט ריק, לא ניתן להשתמש בסוגריים מסולסלים ריקים, זה מייצר מילון ריק,צריך להשתמש בפקודה ()a=set

לולאת for בכל שפת תוכנה קיימת פקודה מסוג זה המאפשרת לולאה (loop), העוברת על סדרה של פריטים בתוך אובייקט מסוים, ומבצעת פעולה או בדיקה לכל אחד ואחד מהפריטים הללו. בתנאי שהאובייקט הוא מסוג iterable המאפשר פעולה על כל אחד ואחד מפרטיו. מחרוזות ורשימות, למשל, הם אובייקטים המאפשרים זאת (iterables). ניתן לראות את מבנה לולאת for הכולל יצירת משתנה זמני לצורך ביצוע הלולאה (בדוגמא למטה נקרא item), איזכור שם האובייקט (מחרוזת רשימה וכו' – בדוגמא למטה נקרא Alphabet) לאחר מכן נקודתיים (:) ובשורה מתחת, שהזחנו ימינה, אנו רושמים את הפעולה שאנו רוצים לבצע - ונדגים – Alphabet="abcd" for item in Alphabet: print (item) >>> a b c d בתוכנית למעלה יצרנו מחרוזת שקראנו לה Alphabet וביקשנו מהמחשב לעבור כל פריט ופריט (item) בתוך המחרוזת ולהדפיס אותו. המילה item, שהיא משתנה זמני, יכולה להיות כל שם אחר שנבחר, והמשתנה הזה בכל פעם מכיל איבר אחר של המחרוזת, והלולאה for שיצרנו מדפיסה את אותו ערך שיש באותו רגע במשתנה הזמני (ב- item) עד שהיא מסיימת לעבור על כל המחרוזת ואז מפסיקה. ולדוגמא נוספת – lista=[1,2,3,4] for num in lista: print (num**2) >>> 1 4 9 16 בתוכנית למעלה יצרנו רשימה המכילה את המספרים מ- 1 עד 4, ביקשנו מהתוכנה באמצעות לולאת for ליצור לולאה העוברת על כל אחד מהפריטים ברשימה lista ולהדפיס את ריבוע כל אחד ואחד מהפריטים ברשימה. שוב, המילה num היא משתנה שבחרנו וניתן לקרוא לו בכל שם (שאינו נמנה על השמות המהווים פקודות בפייתון ואינם ניתנים לשימוש). כדי להבין היטב איך טכנית פועלת לולאה – נסבך מעט - lista=[1,2,3,4] for num in lista: lista.remove (num) print(lista) >>> [2, 4] בתוכנית למעלה היינו יכולים לצפות שבכל פעם ימחק פרט מהרשימה עד שהיא תהיה ריקה, אך הלולאה אינה עובדת כך, תחילה הלולאה מבצעת פעולה על האיבר הראשון ברשימה ומוחקת אותו, כעת הרשימה מכילה את המספרים [2,3,4] בסיבוב הבא הלולאה מוחקת את האיבר השני ברשימה החדשה ולא ברשימה המקורית! ואנו נותרים עם [2,4] כעת אין איבר שלישי ורביעי ולכן פעולת הלולאה מסתיימת. מה תעשה התוכנית הבאה ? list1=[1,2,3,4] list2=[ ] for num in list1: list2.append (num*2) print(list2) >>> [2, 4, 6, 8] בתוכנית למעלה יצרנו רשימה בשם list1 הכוללת את המספרים מ- 1 עד 4 וגם יצרנו רשימה שנייה ריקה בשם list2. ביקשנו מפייתון לעבור על הפריטים ברשימה הראשונה ובכל פעם להוסיף לרשימה השנייה את תוצאת המכפלה ב- 2 של כל פריט ברשימה הראשונה. לבסוף להדפיס את הרשימה השנייה שהתמלאה, בסוף הלולאה, בארבעה מספרים הכפולים מהמספרים ברשימה הראשונה.

פעולת range פעמים רבות משלבים את פקודת for עם פקודה אחרת בשם range ו ונראה מה פקודה זו מבצעת (הגם שהמונח פקודה הוא לא מדויק בהמשך נלמד מה בדיוק היצור הזה) – for num in range(5): print (num) >>> 0 1 2 3 4 ניתן להתייחס אל פקודת ה- range כאובייקט מיוחד המייצר בכל פעם מספר אחד בטווח המספרים מ- 0 ועד למספר שנקבנו בו בפקודת ה- range (לא כולל את המספר עצמו) – תכונה זו נקראת iteration ופקודת rang מייצרת איטרטור (iterator -אני לא אחראי לשמות). ניתן לקבוע מהיכן תתחיל הספירה, מתי היא תפסיק ובאלה קפיצות – for num in range(1,10,2): print (num) >>> 1 3 5 7 9 בתוכנית למעלה ביקשנו להדפיס את המספרים החל מהמספר 1 (לא מאפס) ועד 10 (לא כולל 10) בקפיצות של 2. אפשר לעשות דברים יותר מורכבים – lista=["a","b","c","d"] for i in range (len(lista)): print (lista[ i ]) >>> a b c d התוכנית למעלה מבצעת לולאת for יחד עם פקודת range שבמקום פרמטר מספרי הכנסנו ל- range את אורך הרשימה (len(lista שהוא במקרה הזה שווה ל – 4 וכך הצלחנו לגרום לתוכנית להדפיס את איברי הרשימה, החל מ- lista[0] ועד lista[3] . כעת גם אם נוסיף איברים לרשימה ואורכה יתארך, התוכנית עדיין תעבוד. אפשר להשתמש בפקודת range בשילוב עם הפקודה list על מנת לייצר רשימות מספרים מהירות – lista=list(range(10)) print (lista) >>> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

פעולות מסיימות בלולאות pass, continue, break לולאות (loops) מסוג while או for למשל, ממשיכות לרוץ (לעיתים לנצח) אלא אם מתקיים תנאי שמפסיק אותן. בפייתון קיימים כמה הוראות המתייחסות ללולאות, אחת מהן נקראת pass והיא לא עושה שום דבר מלבד למלא מקום ריק אולי על מנת בהמשך לבצע פעולה ממשית במקומה. הפקודה continue מבקשת מהלולאה לדלג לפריט הבא בתור בלי לעשות דבר, והפקודה האחרונה נקראת break והיא מסיימת את עבודת הלולאה באופן שהיא לא ממשיכה יותר לרוץ. lista=[1,2,3,4,5,"banana"] for item in lista: if item==2: pass if item==3: continue if item==5: break else: print(item) >>> 1 2 4 התוכנית למעלה יוצרת רשימה של המספרים 1 עד 5 ובסופה גם פריט אקזוטי, המילה banana. אם פריט ברשימה צולח בשלום את שלושת התנאים התוכנית מדפיסה אותו ועוברת לפריט הבא – זו המשמעות של הלולאה הספציפית הזאת. המספר 1 אינו נלכד באף אחד מהתנאים (if) ולכן הוא מודפס. המספר 2 נלכד בתנאי if item==2 אבל ההוראה pass לא עושה שום דבר מלבד למלא את החלל מתחת ל- if ) if בלא הוראה מתחת יחשב לשגיאה) ולכן התוכנית ממשיכה לרוץ כסדרה ומדפיסה את המספר 2. המספר 3 נלכד בתנאי if item==3 וכאן ההוראה היא continue כלומר הלולאה ממשיכה לפריט הבא ברשימה (המספר 4) מבלי לבצע את השורות שמתחת, ולכן גם לא מדפיסה את המספר 3. המספר 4 אינו נלכד באף תנאי ולכן מודפס. המספר 5 נלכד בתנאי if item==5 וכאן ההוראה היא break כלומר, לסיים מיידית את עבודת הלולאה הזאת (מסוג for) ולכן הלולאה לא ממשיכה לשורות למטה (ולא מדפיסה את המספר 5) וגם לא ממשיכה לרוץ על פריטים נוספים ברשימה והמילה banana בסוף הרשימה לא זוכה להיות מודפסת כלל.

מודולו % modulo וחילוק רצפה floor division // modulo בפייתון זה לא אחוז ואין לזה קשר לאחוזים, מודולו היא פעולה מתמטית חשובה בעולם התכנות, והיא מחשבת את השארית הנותרת לאחר פעולת חילוק, אבל רק את השארית, לא את כל התוצאה! x=9%4 print(x) >>> 1 x=12%3 print(x) >>> 0 תוצאת החילוק של 9 ב- 4 היא 2 ושארית 1 – מה שמעניין אותנו כאן זה השארית. תוצאת החילוק של 12 ב- 3 היא 4 בלי שארית ולכן אנו מקבלים את התוצאה 0. למה זה טוב ? למשל כדי להוציא מתוך רשימה של מספרים רק את המספרים הזוגיים – for i in range (5): if i%2==0: print(i) >>> 0 2 4 בתוכנית למעלה אנו רואים שבטווח שבין 0 עד 5 (לא כולל 5) כל מספר שחלוקתו ב- 2 נותרת ללא שארית (מספר זוגי או אפס) יודפס. אפשר גם באותו אופן לקבל את המספרים האי זוגיים בטווח על ידי שימוש במודולו ובביטוי לא שווה (!=) – for i in range (5): if i%2 !=0: print(i) >>> 1 3 החלק של חילוק הרצפה //, בהמשך, אחרי התרגיל הבא.

תרגיל – תוכנית למציאת מספרים ראשוניים בין 0 ל- 100 מספר ראשוני הוא מספר המתחלק רק בעצמו וב- 1 ונותן תוצאה שלימה ולא בשום מספר אחר. for num in range (101): if num > 1: for i in range(2,num): if (num % i) == 0: break else: print(num) >>> 2 3 5 7 11 13 17 19 23 29 … *למען הקיצור כתבנו רק את עשרת המספרים הראשוניים שמצאנו באמצעות התוכנית. הלולאה הראשונה רצה על המספרים מ – 0 עד 101 (לא כולל 101 אבל כן כולל את 100). היא מתחילה להדפיס החל מהמספר 2 באמצעות מסננת של פקודת if num>1, ולגבי מספרים הגדולים מ-1 יצרנו לולאה פנימית נוספת, שרצה על המספרים מ- 2 ועד למספר שנמצא בתור בלולאה הראשונה (בתוך המשתנה num) ומחלקת אותו בכל אחד מהמספרים הקטנים ממנו באמצעות הלולאה הפנימית (שם כל מספר הקטן מהמספר אותו אנו בודקים מסומנן ב – i) – כך למשל אם הגענו למספר 5, הלולאה הפנימית מחלקת אותו במספרים 2,3 ו- 4 זאת משום ש- (range(2,5 לא כולל את המספר 5, ובודקת האם התוצאה של חלוקת המספר 5 בכל אחד מהמספרים שלפניו (2,3,4) היא בעלת שארית 0 – כאשר שארית 0 אומרת לנו שהמספר מתחלק באופן שלם במספר אחר שהוא לא עצמו או 1 ולכן אינו ראשוני – במקרה כזה ההוראה היא break והלולאה הפנימית נשברת ולא ממשיכה לרוץ ולא מגיעה לפקודה. (print(num אם המספר הוא ראשוני, הוא צולח את חלוקת המספרים הקטנים ממנו (חוץ מ- 1) כאשר תמיד נותרת שארית הגדולה מ- 0, ולכן פקודת break לא יוצאת לפועל, והוא מודפס בשלום.

Floor division הפעולה ההפוכה לפעולת המודולו (במובן מסוים) היא חילוק רצפה floor division (אם יש שם טוב יותר בעברית...) פעולה הנותנת לנו את תוצאת החילוק בלי שאריות. במקום slash אחד כמו בחילוק רגיל, יש לנו slash כפול, הנה שני תרגילים שהתוצאה שלהם זהה: 15//7=2 20//7=2 בואו נראה (מי שרוצה מוזמן לנסות את זה כתרגיל) איך אנו יכולים להשתמש בחילוק רצפה // כדי לקחת מספר כלשהו (נניח בעל חמש ספרות) המוצב במשתנה x ולקצץ ממנו כל פעם רק את ספרת היחידות, עד שנותרים עם הספרה האחרונה. x=913647 while x>9: x//=10 print(x) >>> 91364 9136 913 91 9 לקחנו את המספר 913647 ובנינו לולאת while שבכל פעם משאירה לנו את תוצאת החילוק ב- 10(בלי שארית) – שזה בעצם לקצץ את ספרת היחידות - ומציבה את התוצאה חזרה ב-x ואח"כ מדפיסה את הערך של x. כל פעם הלולאה מורידה עוד ספרה, עד שהיא מגיעה לסוף. התנאי x>9 בא לוודא עצירה של הלולאה רק כשיש מספר חד ספרתי.

פורמט – format פייתון מסייעת לנו להדפיס נתונים בתוך קונטקסט כך שנבין טוב יותר על מה מדובר, על מנת לעשות זאת אנו צריך לשלב בתוך שורת טקסט משתנים, ואנו צריכים שהתוכנה תבדיל בין אלה לאלה. בעבר היו דרכים מורכבות יותר לעשות זאת, והיום זה פשוט מאוד. הדרך הפשוטה ביותר היא לרשום את האות f (מהמילה format) לפני המחרוזת, ובתוך סוגריים מסולסלים, להציב את המשתנים, והתוכנה כבר תחבר אותם יפה. בואו נראה איך עושים את זה – x=5 print (f"roni is {x} years old") >>> roni is 5 years old עוד אחת kinderlach={"roni":5,"matan":4.5,"ruti":4} for key,value in kinderlach.items(): print(f"{key} is {value} years old") >>> roni is 5 years old matan is 4.5 years old ruti is 4 years old אפשר גם ככה – ((print("{} is {} years old".format(key, value ואפשר גם בדרכים אחרות שהיו מקובלות יותר בדור הקודם של פייתון.

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

לוגיקה בוליאנית boolean קשה לדמיין שפת תכנות בלי להשתכשך בלוגיקה בוליאנית שהתוצרים שלה הם נכון או לא נכון True או False והן נכתבות עם אותיות רישיות גדולות, ללמד על מעמדן המיוחד בפייתון. x=2**3 print (x is 8) >>> True בהתחלה אנו מציבים ב x את הערך 8 (2 בחזקת 3) ולאחר מכן שואלים את התוכנה האם x הוא 8 והתשובה הלא מפתיעה שלה היא שההיגד הזה (x is 8 ) הוא נכון True. x=2**3 print (x == 7) >>> False ההיגד x שווה ל- 7 אינו נכון ולכן נקבל False . פייתון יודעת גם להתייחס בהקשר המתאים ל- True כ- 1 ול – False כ- 0 – print (True * 5) >>> 5 וקצת נתחכם - print (0==False) >>> True print (0 is False) >>> False למעלה אנו יכולים לראות את האבחנה בין is ל- ==. אפס שווה מתמטית לערך של false אבל הם טיפוסים שונים ולכן אין זהות ביניהם. אחד השימושים הוא יצירת לולאה אינסופית באמצעות הביטוי while True שתופסק בהמשך באמצעות רק באמצעות תנאי ופקודת break - n=0 while True: if n==5: break else: print (n) n+=1 >>> 0 1 2 3 4 ראשית יצרנו משתנה n מחוץ ללולאה אשר בכל סיבוב גדל ב- 1. לאחר מכן יצרנו לולאה אינסופית שנשברת רק כאשר n שווה ל- 5. הניסוח שלמעלה מבלבל מעט – כי הפירוש המילולי של while True הוא "כל זמן שנכון" אז... – מה נכון ? כל זמן שהביטוי True הוא נכון (והוא תמיד נכון מכוח הגדרתו) הלולאה תמשיך לרוץ, כלומר לנצח אם לא יהיה משהוא אחר שיעצור אותה כמו break.