נדבר על מהן רשימות, נדבר על הקשר בין מחרוזת לרשימה ונראה איך רשימה של רשימות היא בעצם טבלה.

על מה נעבור

• מוטיבציה
• יצירת רשימה
• גישה לאיברי הרשימה
  • גישה ישירה קלאסית
  • גישה ישירה הפוכה
  • גישה לתת רשימה
• הוספה לרשימה
• רשימה דו-מימדית (רשימה של רשימות)
  • גישה לאיברי הרשימה
• חילוץ משתנים מרשימה

מוטיבציה

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

יצירת רשימה

כדי ליצור רשימה בפייתון נכניס לתוך סוגריים מרובעים את איברי הרשימה, מופרדים ע״י פסיק

1my_first_list = [1, 2, 3, 4, 5, 6, 7, 'a', 'b', True]

גישה לאיברי הרשימה

גישה לאיברי הרשימה תתבצע ע״י כתיבת שם הרשימה ובצמוד סוגריים מרובעים המכילים את אינדקס האיבר הרצוי.

גישה ישירה קלאסית

כל עצם במערך נקרא איבר (באנגלית element) וגישה אל אברי המערך מתבצעת ע״י גישה למקום בו הם נמצאים ברשימה. מיקום איבר במערך נקרא אינדקס האיבר.

ברוב המכריע של שפות התכנות, אינדקס הרשימה מתחיל ב-0 ולא ב-1. לכן, אורך הרשימה שונה מהאינדקס בו נמצא האיבר האחרון שלה (תמיד 1 פחות מאורך הרשימה) לכן, אם נרצה לגשת לאיבר החמישי במערך אנו נעשה זאת ע״י פניה לאינדקס 4

1my_first_list = [1, 2, 3, 4, 5, 6, 7, 'a', 'b', True]
2
3fifth_element = my_first_list[4]  # fifth_element = 5

גישה ישירה הפוכה

ניתן לגשת לאיברי המערך דרך אינדקסים שליליים. מספר שלילי מייצג את מיקום האיבר מסוף הרשימה.

1my_first_list = [1, 2, 3, 4, 5, 6, 7, 'a', 'b', True]
2
3last_element = my_first_list[-1]  # last_element = True
4second_to_last_element = my_first_list[-2]  # second_to_last_element = 'b'

גישה לתת רשימה

פעולה זו נקראית slicing (חיתוך). בתוך סוגריים מרובעים נכתוב את האינדקס ההתחלתי והאינדקס הסופי כאשר הם מופרדים ע״י נקודותיים

1my_first_list = [1, 2, 3, 4, 5, 6, 7, 'a', 'b', True]
2
3my_first_sub_list = my_first_list[0:4]  # my_first_sub_list = [1, 2, 3, 4]

האינדקס הסופי לא נכלל בחיתוך ולכן ניתן להגיד- מאינדקס התחלתי כולל ועד אינדקס סופי לא כולל

ניתן גם לבצע slicing עם אינדקסים שליליים

1my_first_list = [1, 2, 3, 4, 5, 6, 7, 'a', 'b', True]
2my_second_sub_list = my_first_list[5:-2] # my_second_sub_list = [6, 7, 8, 'a']
3my_third_sub_list = my_first_list[-3:-1] # my_third_sub_list = ['a', 'b']

כאשר רוצים לבצע חיתוך מאינדקס מסוים ועד סוף הרשימה ניתן להשמיט את האינדקס הסופי בתוך הסוגריים המרובעים

1my_first_list = [1, 2, 3, 4, 5, 6, 7, 'a', 'b', True]
2my_forth_sub_list = my_first_list[5:] # my_forth_sub_list = [6, 7, 8, 'a', 'b', True]

הוספה לרשימה

כדי להוסיף איבר לרשימה, נשתמש בפוקנציה append אותה נפעיל על המשתנה ש״מחזיק״ ברשימה. לפונקציה נעביר את האיבר אותו ברצננו להוסיף לרשימה.
האיבר יתווסף לסוף הרשימה וגודל הרשימה יגדל ב-1.

1some_list = []
2some_list.append(2)
3print(some_list)

1[2]

1some_list.append(5)
2print(some_list)

1[2, 5]

ניתן לחבר בין רשימות ע״י שימוש בפונקציה extend, לתוכה נעביר את הרשימה אותה ברצננו להוסיף

1some_list = [1, 2, 3]
2some_list.extend([4, 5, 6])
3print(some_list)

1[1, 2, 3, 4, 5, 6]

אפשר גם לחבר רשימות באמצעות האופרטור +

1some_list1 = [1, 2, 3]
2some_list2 = [4, 5, 6]
3some_list = some_list1 + some_list2
4print(some_list)

1[1, 2, 3, 4, 5, 6]

מחרוזת כרשימה

כל מחרוזת היא למעשה רשימה של אותיות ולכן בדומה לרשימה אנו יכולים לגשת לתת מחרוזת או לאותיות ספציפיות באמצעות אינדקסים.

Copy

1user_command = "click 13A"
2
3print(user_command[:5]) # will print "click"
4
5print(user_command[6:]) # will print "13A"
6
7print(user_command[2]) # will print "i"
8
9print(user_command[-1]) # will print "A"

הפונקציה split

לעיתים אנחנו רוצים לחלק את המחרוזת למספר חלקים בהתאם לתו כלשהו המוגדר כ״מפריד״ (seperator).
במשחק שלנו אנחנו נשתמש בפונקציה split כדי לעבד את הקלט של המשתמש. לדוגמה - כאשר המשתמש משתמש בפקודת click.
נזכיר כי כדי ללחוץ על תא מסוים בלוח, המשתמש מזין את הפקודה: click 5B.
כדי לעבד את הקלט, נפצל את המחרוזת כאשר התו המפריד הוא ״ ״ (רווח) כדי לעבד בנפרד את הפקודה ("click") והפרמטרים ("5B").

Copy

1command = "click 5B"
2parsed_command = command.split(" ")
3
4print(parsed_command[0]) # will print click
5print(parsed_command[1]) # will print 5B
6

רשימה דו-מימדית (רשימה של רשימות)

נגדיר רשימה דו-מימדית

1 d2_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

גישה לאיברי הרשימה

כעת, בדומה לגישה לרשימה רגילה נשתמש באינדקסים. שימו לב שכל איבר ברשימה הוא רשימה בעצמו ולכן גם לכל איבר יש אינדקסים משלו, בנוסף לרשימה ההמכילה את הרשימות. כאשר נרצה לגשת לאיבר כלשהו ברשימה נשתמש באינדקסים כפולים. לדוגמה

1 d2_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
2first_element_of_first_element = d2_list[0][0] # first_element_of_first_element=0
3second_element_of_second_element = d2_list[1][1] # second_element_of_second_element=5
4second_element_of_third_element = d2_list[2][1] # second_element_of_third_element=8

כך נשנה את הספרה 6 למספר 60

1d2_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
2d2_list[1][2] = 60
3print(d2_list)

1[[1, 2, 3], [4, 5, 60], [7, 8, 9]]

הקשר בין רשימה דו-מימדית לטבלה

ניתן לראות שרשימה דו-מימדית (רשימה של רשימות) ניתנת לייצוג כטבלה, כאשר כל תת-רשימה הינה שורה בטבלה

אורך תתי הרשימות חייב להיות זהה.

לכן, ניתן גם לקרוא לרשימה דו-מימדית מטריצה (matrix).

index	0	1	2
0	1	2	3
1	4	5	6
2	7	8	9

התוכנית הבאה מייצרת רשימה דו-מימדית אשר מכילה רשימות בעלות 10 איברים כל אחת. כלומר, טבלה 10x10. נסו לצייר סמיילי ע״י הזנת האינדקסים המתאימים, הניגשים ישירות לאברי הרשימות. לדוגמה, כדי ״לצייר את האות P, נעביר את האינדקסים הבאים (ראו את הדוגמה במשחק הנ״ל):
1,1
1,2
1,3
1,4
2,1
2,4
3,1
3,2
3,3
3,4
4,1
5,1
6,1

לחצו כאן כדי לראות את הקוד

חילוץ משתנים מרשימה

ניתן להגדיר משתנים מתוך רשימה בצורה ישירה, בצורה הבאה:

1some_list = [1, 2, 3]
2one, two, three = some_list
3print(one)
4print(two)
5print(three)

11
22
33

שימו לב שמספר המשתנים חייב להיות שווה למספר האיברים ברשימה, אחרת התוכנית תקפיץ שגיאה