‫עוד מבני נתונים‬ ‫רות בורנשטין‬

‫‪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‫אם ננסה לשנות איבר ב‬
‫הודעת שגיאה‬
Traceback (most recent call last):

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']
Traceback (most recent call last):
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: