פרק קודם:

מה נלמד

• רשימות - Lists
• מהו טופל - Tuple
• הכל על סטים - Sets
• מהו מילון - Dictionaries

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

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

רשימה/מערך - List/Array

זוכרים רשימה ומערכים?
אם לא ממליץ לעבור על הפרק הזה שוב:

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

סידור רשימה

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

תנסו את הקוד, מה יודפס?
תנסו לנחש לפני שאתם מריצים את הקוד.

1
2
3

arr = [5, 2, 6, 9, 1]
arr.sort()
print(arr)

הקריאה לפונקציה הזו מסדרת את הרשימה.
ניתן להפוך את הסדר ע”י כתיבה לפרמטר של הפונקציה הזו.
הפרמטר נקרא reverse והוא מקבל False או True.
אם לא נותנים לו שום פרמטר בברירת מחדל הוא מבצע בסדר עולה.

1
2
3

arr = [5, 2, 6, 9, 1]
arr.sort(reverse = True)
print(arr)

sort(key) - סידור ע”פ פונקציה

להעביר פונקציה כפרמטר

על מנת להבין את פנוקציית ה-Sort וkey נסתכל קודם איך אנחנו מעבירים פונק’ כפרמטר.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

def Calculate(a, b):
    return a + b

def Calculate2(a, b):
    return a - b

def Calculator(a,b, symbol, addFunc, subFunc):
    if symbol == '+':
        return addFunc(a,b)
    elif symbol == '-':
        return subFunc(a,b)


a = int(input('First number: '))
b = int(input('Second number: '))
symbol = input('Pick a symbol + or - :')

#                      First func, Second Func
Calculator(a,b,symbol, Calculate, Calculate2)

העברנו לפונק’ הראשית שני פונקציות משניות - כזו שמבצעת חיבור וכזו שמבצעת חיסור.
השם של הפונק’ יכול להיות משומש כערך שניתן להעביר, ולקרוא לו.
מה קורה כשאנחנו מעבירים מספר בפרמטר שצריך להיות פונק?

1
2
3
4

def MyFunc(func):
    func()

MyFunc(3)

הפונק’ הגדולה מצפה לפונקציה כפרמטר משום שאנחנו קוראים לה עם הסוגריים.

func()

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

1
2
3
4
5
6
7

def PrintHelloWorld():
    print("Hello World")

def MyFunc(func):
    func()

MyFunc(PrintHelloWorld)

חזרה לפונקציה הSort שלנו.
זה הגיוני יותר לסדר רשימות של מספרים כי בוודאות אנחנו יודעים מה יותר גדול ממה.
למשל 2 בברור גדול מ1 אבל 4 גדול 2, לכן תמיד נוכל לסדר אותם בצורה:
1, 2, 4
או הפוך
4, 2, 1.

מה קורה כשאנחנו רוצים לסדר רשימה של מחרוזות?
הרי מחרוזת זה לא מספר, איך אנחנו יודעים שמחרוזת גדולה יותר ממחרוזת אחרת?
נוכל לנסות לנחש - ע”פ אורך המחרוזת, ע”פ כמות האותיות הקטנות , או שזה מחרוזת שמתארת מספרים.

לפונקציה sort יש פרמטר שנקרא key שבעצם מקבל פונקציה.
הפונקציה הזו מתארת כיצד לקחת את האיבר ולהפוך אותו למספר ככה שנוכל בעצם לסדר את הרשימה.
הפונקציה הזו צריכה להחזיר מס’, לפי המס’ הזה הוא מבצע סידור.

למשל, סידור מערך מחרוזות ע”פ גודל המחרוזת:

1
2
3
4
5
6

def SortBy(element):
    return len(element) # חייב להחזיר מספר!  

arr = ['AAA','AA', 'AAAA','A']
arr.sort(key = SortBy)
print(arr)

הפונק’ sort קוראת לפונק’ key על כל אלמנט.
ומחזירה את האורך שלו כי בעצם המימוש של SortBy הוא לקחת את האלמנט ולעשות עליו פונק’ len שמחזירה את כמות התווים שיש במחרוזת.

מה ייקרה אם תוסיפו reserve?

1
2
3
4
5
6

def SortBy(element):
    return len(element) # חייב להחזיר מספר!  

arr = ['AAA','AA', 'AAAA','A']
arr.sort(key = SortBy, reverse = True)
print(arr)

תרגיל

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

על מנת לתת לsort את הפונקציה שבעזרתה אנחנו בוחרים ע”פ מה לסדר, ניתן להשתמש בפרמטר key.
השלימו את הפונק’ SortBy.

1
2
3
4
5
6

def SortBy(element):
    pass

fruits = [['Apples', 4], ['Bananas', 9], ['Pears', 2],['Oranges', 3]]
fruits.sort(key = SortBy)
print(fruits)

Answer

1 2 3 4 5 6

def SortBy(element): return element[1] fruits = [['Apples', 4], ['Bananas', 9], ['Pears', 2], ['Oranges', 3]] fruits.sort(key = SortBy) print(fruits)

בגלל המערך של המערכים הפונקציה לא יודעת מה בדיוק להשתמש בו כערך מספרי, כי כדי לסדר ערכים צריך לדעת אם אלמנט מסוים גדול, קטן או שווה.
וכשכל ערך הוא מערך בפני עצמו - הפונקציה לא יודעת כיצד לסדר אותם אלה אם כן נביא דרך הפונקציה מספר כלשהו.
כל element בפונקציה SortyBy הוא מערך.

טופל - Tuple

טופל זה רשימה של ערכים, כמו הרשימה שלמדנו כבר, אך ההבדל הוא שהוא לא יכול להשתנות.
אחרי שיוצרים טופל, לא ניתן לשנות את מס’ הערכים שלו.
ערכים שלא יכולים להשתנות נקראים const או immutables.

כאשר אומרים שערך הוא Mutable זה אומר שהוא בר שינוי - כלומר ניתן לערוך אותו.
לכן ניתן לומר שTupleים הוא Immutable.

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

מאתחיל טופל בעזרת סוגריים מעוגלים, להלן דוגמת קוד:

1
2
3
4
5
6
7
8

myTuple = (1,2,3)
print(myTuple)

singleItemTuple = (1,) # טול עם אלמנט בודד בתוכו
print(singleItemTuple)

amount = len(myTuple)
print(f"myTuple has {amount} elements")

בדוגמא הבאה נראה הדגמה של טאפל וחוסר היכולת שלו לשנות ולהשתנות:

פונקציות של טופל

יש כמה פונקציות בודדות למקרה שנרצה להשתמש בהן.

count

מוצא לנו כמה פעמים יש את הערך בתוך הטופל.
מה הפונקציה הזו תדפיס?

1
2

myTuple = (1,2,3,4,5,4,3,2,1)
print(myTuple.count(2))

index

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

1
2

myTuple = (1,2,3,4,5,4,3,2,1)
print(myTuple.index(2))

זוכרים למה זה ידפיס 1?

סט - Sets

סט הוא גם סוג של רשימה!
לא ניתן לשנות את הערכים בתוך הסט, אך ניתן למחוק אותם או להוסיף לסט.

סט מגדירים בעזרת הסוגריים המסולסים.

1
2

mySet = {1, 2, 3}
print(mySet)

אין גישה בעזרת אינדקס

לעומת רשימות לא ניתן להשתמש באינדקסים כדי לגשת לסט.
מה ייקרה כאן?

1
2

mySet = {1, 2, 3}
print(mySet[0])

ריצה עם לולאה

למדנו שלסטים אין גישה לאינדקסים - אבל ניתן לגשת לכל איבר בעזרת לולאת for.

1
2
3

mySet = {"Apple", "Banana", "Pear"}
for fruit in mySet:
    print(fruit)

להוסיף ולהוריד ערכים

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

להוסיף ערך יש את הפונקציה add.
להוריד ערכים יש 2 פונקציות:

• remove
• discard

ההבדל בין השניים זה הבדיקה אם ערך קיים או לא בתוך הסט.

• remove - בודק אם הוא קיים ואם הוא לא קיים הוא מתריע שלא קיים.
• discard - לא בודק אם הוא קיים ובמידה ולא קיים הוא לא עושה כלום.

לרוב כדאי להשתמש בsicard אך כאשר הערך שאתם מורידים מהסט הוא חשוב, אז עדיף להשתמש בremove.

1
2
3
4
5
6
7
8
9
10

mySet = {"Apple", "Banana", "Pear"}
print(mySet)
mySet.add("strawberry")
print(mySet)
mySet.remove("strawberry")
print(mySet)
mySet.add("strawberry")
print(mySet)
mySet.discard("strawberry")
print(mySet)

update

ניתן להוסיף ערך בודד, מה שמיוחד בסט הוא מאפשר לעדכן אותו בעזרת הרבה ערכים!
בעזרת רשימה, טופל, סט אחר, או מילון!.

1
2
3
4
5
6
7
8
9

mySet = {1,2,3}
mySet2 = {4,5,6}
myList = [7,8,9]
myTuple = (10,11,12)

mySet.update(mySet2)
mySet.update(myList)
mySet.update(myTuple)
print(mySet)

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

מילונים

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

למשל:

תַּפּוּחַ - זכר
פרי עגול ומתוק הצומח על עץ בצבעים ירוק, אדום וצהוב

בפסודו קוד נוכל לכתוב את זה כך:

1
2
3
4
5

מילון פירות:
תפוח => פרי עגול ומתוק הצומח על עץ בצבעים ירוק, אדום וצהוב  


הדפסה(פירות[תפוח])

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

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

1

dictionary = { key: value }

קוד פייתון:

1
2
3

fruits = {'apple' : 'A round and sweet fruit that grows on tress in the color of green, red or yellow'}

print(fruits['apple'])

מה שזה מדפיס:

ערכים במילון

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

דוגמא:

1
2
3
4

fruitPrices = { 'Apple' : 5 , 'Banana': 7}
fruitPrices['Strawberry'] = 15

print(fruitPrices)

אם המפתח היה ערך מספרי, היה ניתן להשתמש בו גם כן:

1
2

errorCodeToDescription = {404 : 'Not Found', 200 : 'Ok'}
print(errorCodeToDescription[200])

מחיקת ערכים

על מנת להוריד ערך ניתן להשתמש ב2 פונקציות:

• pop(key) - מוריד ערך בעזרת המפתח שלו.
• popitem() - מוריד את הערך האחרון שהוכנס.

1
2
3
4
5
6
7
8

fruitPrices = { 'Apple' : 5 , 'Banana': 7 , 'Pear': 6}
print(fruitPrices)

fruitPrices.popitem()
print(fruitPrices)

fruitPrices.pop('Banana')
print(fruitPrices)

גישה לערכים ולמפתחות

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

• keys() - רשימה של כל המפתחות.
• values() - רשימה של כל הערכים.

תרגיל

ברשימת הפירות שלנו מצאו את שם הפרי עם הכי הרבה אותיות.
ממשו את הפונקציה:

1
2
3
4
5
6
7

fruitPrices = { 'Apple' : 5 , 'Banana': 7 , 'Pear': 6}

def FindLongestFruitName(fuirtDictionary):
    pass

longestFruitName = FindLongestFruitName(fruitPrices)
print(longestFruitName)

1
2
3
4
5
6
7
8
9
10
11
12
13

fruitPrices = { 'Apple' : 5 , 'Banana': 7 , 'Pear': 6}

def FindLongestFruitName(fruitDictionary):
    maxLetters = 0
    lognestFruit = ''
    for fruitName in fruitDictionary.keys(): # נרוץ על כל המפתחות כי רק הם רלוונטיים
        if (length := len(fruitName)) > maxLetters: # נבדוק אם האורך של השם גדול מהאורך ששמרנו בצד- שימו לב שהאורך הראשון תמיד יהיה גדול מ0.  
            maxLetters = length # נשמור את הערך כהערך המקסימלי
            lognestFruit = fruitName # נשמור את השם בשביל שנחזיר אותו.  
    return lognestFruit

longestFruitName = FindLongestFruitName(fruitPrices)
print(longestFruitName)

1
2
3
4
5
6
7
8
9

def FindLongestFruitName(fruitDictionary):
    maxLetters = 0
    lognestFruit = ''
    for fruitName in fruitDictionary.keys():
        length = len(fruitName)
        if length > maxLetters:
            maxLetters = length
            lognestFruit = fruitName
    return lognestFruit

תרגילים

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

2. כתבו תכנית אשר מכניסה למילון את כל טבלת הכפל, כאשר המפתח יהיה שני המספרים עם כפל ביניהם והערך יהיה התוצאה.
   למשל הערכים הראשונים ייראו כך:

1

{"1*1": 1 , "1*2" : 2, .... "9*9": 81}

3. כמו פונקציה אשר מקבלת שני רשימות ומחזירה מילון אשר המפתח שלו זה כל ערך בתוך הרשימות, כל ערך במילון הוא כמות הפעמים שהערך הזה מופיע בין שני הרשימות.
   למשל:

1
2
3
4
5

a = [1,1,2]
b = [2,3,4]

# מה שנצפה מהפונקציה הוא:  
c = { 1:1, 2:2, 3:1, 4:1}

1 מופיע פעם אחת בין שני הרשימות,
2 מופיע פעמיים,
3 פעם אחת,
ו4 פעם אחת.

4.
תייצרו מערך עם 10,000 מספרים רנדומליים, ככה ניתן לייצר מספר רנדומלי:

1
2

import random
random.randint(1, 100))

תספרו כמה מספרים זוגיים ואי זוגיים יש ותכניסו את זה למילון בצורה הבאה:

1

myDictionary = { 'even':0, 'odd':0 }

1
2
3
4
5
6
7
8
9
10
11
12

def FuncWithSideEffect(arr):
    arr.append(1)

a = [1,2,3]
FuncWithSideEffect(a)
print(a)

def FuncWithNoSideEffect(tuple):
    pass

b = (1,2,3)
FuncWithNoSideEffect(b)

1
2
3
4
5
6
7
8
9

resultDictionary = { }

for num in range(1, 10):
    for num2 in range(1, 10):
        key = f"{num}*{num2}"
        resultDictionary[key] = num * num2

print(resultDictionary)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

a = [1, 1, 2]
b = [2, 3, 4]
expected = { 1:2, 2:2, 3:1, 4:1}


def CountDoubleOccurrences(arr, arr2):
    dic = {}
    for num in arr:
        dic[num] = 1
    for num in arr2:
        if num in dic:
            dic[num] = dic[num] + 1
        else:
            dic[num] = 1
    return dic

result = CountDoubleOccurrences(a, b)
print(result)

1
2
3
4
5
6
7
8
9
10
11
12

import random

dic = { 'even': 0, 'odd': 0 }
for num in range(1,10000): 
    randNum = random.randint(1, 100)
    if randNum % 2 == 0:
        dic['even'] = dic['even'] + 1
    else:
        dic['odd'] = dic['odd'] + 1

print(dic)

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