courses/python101/lessons/python-install/python-install.md

בשיעור זה נסביר איך להתקין **פייתון** במערכת הפעלה **Windows**.

 


## על מה נעבור 

## שלב 1 - התקנת Interpreter (אינטפרטר)
האינטפרטר, או בשמו העברי- ה״מפרש״, הוא למעשה הרכיב שמאפשר לנו להריץ פייתון על המחשב.
- ניגש לאתר הרשמי של פייתון.
 - [הורדת פייתון](https://python.org/download).
- בתפריט Downloads בחרו את גרסת הפייתון האחרונה (כל עוד מדובר בגירסה 3+, אנחנו בסדר).

 ![הורדת פייתון אתר רשמי אונליין](/images/python101/python_install/python_download1.png "חלון הורדת python מהאתר הרשמי של פייתון אונליין")
- לאחר הורדת קובץ ההתקנה היכנסו אליו (חכו! אל תתקינו עדיין).

![סימון הוספת פייתון לנתיב](/images/python101/python_install/python_installer_1.png "סימון add python to path")
- שימו לב לסמן את Add Python to PATH בתחתית חלונית ההתקנה.

![zoom add python to path](/images/python101/python_install/python_installer_checkbox.png "הגדלה הוספת פייתון")

- התקינו על ידי לחיצה על Install Now

 

## שלב 2 - בדיקת שההתקנה עברה בהצלחה
על מנת לוודא שההתקנה הצליחה, נבצע את הפעולות הבאות:
- לחצו על start, כתבו cmd בשורת החיפוש ופתחו את היישום Command prompt.

![פתיחת cmd לבדיקת אינטפרטר פייתון](/images/python101/python_install/open_cmd.png "פתיחת cmd")

- בחלון שנפתח (הנקרא גם טרמינל) כתבו `python`

![something else](/images/python101/python_install/python_install_run_cmd.png "Some Image for example")

- התוצאה שנרצה לקבל היא הודעה בעלת נוסח **דומה** להודעה הבאה:

```
Python 3.8.9 (default, Apr 13 2022, 08:48:06)
[Clang 13.1.6 (clang-1316.0.21.2.5)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>
```

- במידה ומקבלים הודעה בסגנון הבא, ההתקנה לא הצליחה ועלינו לחזור על התהליך תוך הקפדה על סימון `Add Python to PATH`.

![something else](/images/python101/python_install/python_install_error.JPG "Some Image for example")

- ההתקנה הצליחה? מעולה! אתם יכולים לעבור לשיעור הבא :)
- ההתקנה נכשלה? בדקו שביצעתם את ההוראות כמפורש ואם עדיין לא הצלחתם, כתבו לנו ב-Q&A של השיעור או חפשו האם מישהו כבר שאל שאלה דומה וקיבל תשובה...

התקנת Python (פייתון)

courses/python101/lessons/git-install/git-install.md

## על מה נעבור 

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

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


## התקנת גיט


- ניגש לאתר הרשמי של GIT
 - [הורדת GIT](https://git-scm.com/downloads)
- הורידו את הגירסה שתואמת את מערכת ההפעלה שלכם.
- התקינו את התוכנה.
- בסיום ההתקנה, נבדוק שההתקנה הצליחה.
 - בשורת החיפוש ב-Windows כתבו git והיכנסו ל-Git Bash

 ![something else](/images/python101/git_install/git_install_1.png "גיט שורת פקודה קורס פייתון אונליין")
 - כתבו git ולחצו על Enter- אם רואים רשימה של הפקודות של GIT, ההתקנה הצליחה!
 - הודפסה הודעת שגיאה? כתבו לנו ב-Q&A של השיעור או חפשו האם מישהו כבר שאל שאלה דומה וקיבל תשובה...

התקנת GIT (גיט)

courses/python101/lessons/variables/variables.md

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

## על מה נעבור

## מהי פונקציה

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

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

### איך מזמנים פונקציה?

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

> פונקציה מובנית (built-in function) היא פונקציה שכבר זמינה בשפת התכנות ושניתן לגשת אליה ע״י משתמשי הקצה.

הפונקציה `abs` מקבלת כפרמרטר מספר יחיד, והפעולה שהיא מבצעת הינה חישוב הערך המוחלט של המספר. 
הפונקציה תחזיר מספר חיובי שמייצג את הערך המוחלט של המספר. 
את תוצאת `abs` נכניס לפנקציה המובנית `print`, ה״מדפיסה״ את הערץ אותו היא מקבלת למסך המשתמש, כדי לראות את התוצאה. 

```python
# will print: 5
print(abs(-5))
```

## משתנים

### הגדרת משתנים

משתנה זה מצביע לאובייקט מסויים, שמקבל שם אותו בחר המתכנת. אובייקט יכול להיות מספר, טקסט וגם ערכים נוספים שנלמד בהמשך.
> משתנים הם בעצם תגיות אשר ממפות כתובות בזיכרון המחשב לשמות שלבני אדם קל לעבוד איתם. המשתנים מאפשרים לנו לגשת לערכים השמורים בזיכרון המחשב בקלות ע״י קריאה בשמם. 
> אתם יכולים לתאר כתיבת קוד כאשר במקום משתנים נצטרך לכתוב את הדבר הבא, אשר מייצג כתובת בזיכרון המחשב: 0x2ed98fa1? גם אנחנו לא.

על מנת להגדיר משתנה, נגדיר שם למשתנה, נשתמש בסימן ההשמה `=`, ונגדיר את האובייקט אותו אנו מעוניינים לשמור תחתיו.
< משמעות סימן ההשמה `=` במילים פשוטות: ״קח את מה שנמצא בצד ימין ושים אותו בתוך צד שמאל.

```python: hello
my_first_variable = 15
```

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

<LevelTest>
 <question_block>
 <question>
 כעת תורכם! הגדירו את המשתנה ``my_first_variable`` ושמרו בו את המספר תשעים.
 </question>
 <answer value={"90\n"}/>
 <test value={"print(my_first_variable)"}/>
 </question_block>
 <question_block>
 <question>
מצוין!
כאשר נרצה לגשת לערך אותו מכיל המשתנה, כל שנעשה זה נכתוב את שם שלו.
הדפיסו את הערך השמור במשתנה ``my_first_variable``
 
השתמשו בפונקציית ``print`` כדי להדפיס למסך.
 </question>
 <answer value={"90\n"}/>
 </question_block>
</LevelTest>

### סוגי ערכים שניתן להקצות למשתנה 

ניתן לשמור בתוך משתנה סוגים שונים של ערכים.
הערכים הכי בסיסיים הנקראים גם premitive values (ערכים פרימיטיביים) והם:

| שם | סוג | דוגמא |
|---------|---------------------------|-----------------|
| integer | מספר שלם | `4` |
| float | מספר עשרוני | `4.3` |
| string | מחרוזת (טקסט) | `"hello world"` |
| boolean | ערך בוליאני אמת או שקר | `True` |
| None | הדרך של פייתון לייצג כלום | `None` |

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

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

<LevelTest>
 <question_block>
 <initialCode>
 ```python
 # Dont delete this #
 x = "2"
 y = 2
 boolean_val = 5 == 5
 ######WRITE YOUR CODE BELOW THIS LINE######
 ```
 </initialCode>
 <question>
 מה לדעתכם יודפס למסך בכל אחת מההדפסות? 
נסו להדפיס `x + x`
 </question>
 <answer value={"22\n"}/>
 </question_block>
 <question_block>
 <question>
בזה הרגע חיברתם שתי מחרוזות. ב-Python, חיבור של מחרוזות למעשה משרשר אותם לכן יודפס למסך `22` 
 כעת, נסו להדפיס את `y+y`.
 </question>
 <answer value={"4\n"}/>
 </question_block>
 <question_block>
 <question>
 בזה הרגע חיברתם שני מספרים. ב-Python, חיבור של משתנים מספריים הינו חיבור מתמטי פשוט ועל כן הודפס 4 
 כעת, נסו להדפיס את `boolean_val`.

> הסימן `==` מבצע השוואה בין שני אובייקטים ומחזיר ערך בוליאני אמת אם שני העצמים זהים, אחרת מחזיר שקר. 
> חשוב לא להתבלבל עם סימן ההשמה `=` שמציב את הערך מצד ימין בתוך המשתנה מצד שמאל. 
> **נרחיב על משתנים בוליאנים בשיעורים הבאים.**
 </question>
 <answer value={"True\n"}/>
 </question_block>
 <final_block>
 <message>
 תוצאת ההשוואה בין המספר 5 למספר 5 היא כמובן ״אמת״. הייצוג הטקסטואלי של ״אמת״ ב-Python הינו `True`. 
בשביל הקטע, נסו להדפיס את `x+3`. נסו להבין מדוע קופצת שגיאה.
 </message> 
 </final_block>
</LevelTest>

## קליטת קלט ממשתמש

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

<CoveredIframe loading="lazy" src="https://trinket.io/embed/python/69635d1ce9?runOption=run" width="100%" height="300" frameborder="0" marginwidth="0" marginheight="0" allowfullscreen/>

> הערך שחוזר מהפונקציה `input` **לעולם יהיה מחרוזת!**

## כתיבת תוכנה שכופלת שני מספרים שלמים

התוכנה שלנו תבצע את הפעולות הבאות: 

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

### איך ממירים מחרוזת למספר שלם?

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

| שם הפונקציה | סוג | דוגמא |
|-------------|--------------------------------|-----------------------|
| `int` | המרה של מחרוזת למספר שלם. | `int("4")` -> 4 |
| `float` | המרה של מחרוזת למספר עשרוני. | `float("4.3")` -> 4.3 |
| `str` | המרה של אובייקט כלשהו למחרוזת. | `str(159)` -> "159" |

כיוון שאנחנו מצפים מהמשתמש להכניס מספר שלם נשתמש בפונקציה המובנית `int` כדי להמיר את הקלט למספר שלם.

### כתיבת הקוד
> הסימן `*` הינו פקודה לביצוע כפל
<CoveredIframe loading="lazy" src="https://trinket.io/embed/python/33e1c93505?runOption=run" width="100%" height="300" frameborder="0" marginwidth="0" marginheight="0" allowfullscreen/>
> אתם מוזמנים לשחק עם הקוד. כמה רעיונות: החלפת פעולת הכפל בפעולה אחרת (חיבור `+`, חיסור `-`, חילוק `/` - מה מסוכן בחילוק?) או קבלת קלט של מספר עשרוני.

**סיימנו, כעת אל המטלה בדילוגים**

משתנים ופונקציות מובנות

courses/python101/lessons/simple-if/simple-if.md

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

# תנאים
כמעט כל לוגיקה שנכניס לקוד שלנו מושטתת על תנאים, אם מתקיים א תעשה פעולה 1 אחרת תעשה פעולה 2 וכו. 
לדוגמא - נרצה שהתוכנה שלנו תממש את הלוגיקה הבאה:


<Mermaid chart={`
	flowchart TD;
		INPUT[/קבל טמפרטורה מהחיישן/]--> IF_TEMP{הטמפרטורה גדולה מ-30?};
 IF_TEMP -- אמת --> A[הדפס - 'חם היום, יש לשתות מים']
 IF_TEMP -- שקר --> C[הדפס 'סיום']
 A --> C
`}/>

לטובת הפשטות נוותר על ״קליטת״ הקלט, כבר עשינו זאת בעבר, הפעם נסתפק בהגדרת משתנה פשוט.
```python
temperature = 35 
```
עכשיו נרצה שאם ערכו של המשתנה `temperature` גדול מ-30, יודפס למשתמש שחם היום ולכן מומלץ לשתות הרבה מים. 
כדי לעשות זאת, אנחנו נשתמש במשפט תנאי. 

כדי להגדיר תנאי בקוד, נשתמש במילה השמורה `if` בצירוף ביטוי בוליאני כלשהו. 
לדוגמה:

```python
temperature = 35
if temperature > 30:
 print("it’s hot today!")
 print("drink water!")
print("Done")
```
> שימו לב, גוף משפט התנאי נמצא בהזחה, על כן כל מה שנמצא בתוך הגוף יתבצע רק אם התנאי מתקיים. לעומת זאת, מה שנמצא מחוץ להזחה נמצא מחוץ לתנאי ויתבצע **תמיד**. 
עבוד הטמפרטורה הנתונה יודפס כל מה שנמצא בתוך התנאי וגם יודפס ״סיום״ (כמו שגם מופיע בדיאגרמה).

```bash
its hot today!
drink water!
Done
```
ומה יקרה עבור `temperature = 30`? 
במקרה זה, התנאי לא מתקיים ולכן גוף התנאי לא יתבצע ולכן יודפס למסך `Done` בלבד.
```bash
Done
```

כעת נרצה ״לטפל״ גם במקרה בו הטמפרטורה קטנה מ-25 מעלות:

<Mermaid chart={`
	flowchart TD;
		INPUT[/קבל טמפרטורה מהחיישן/]--> IF_TEMP{הטמפרטורה גדולה מ-30?};
 IF_TEMP -- אמת --> A[הדפס - 'חם היום, יש לשתות מים']
 IF_TEMP -- שקר --> IF_LOWER{הטמפרטורה קטנה מ-25?}
 IF_LOWER -- אמת --> D[הדפס 'מזג אוויר טוב עכשיו']
 IF_LOWER -- שקר --> C[הדפס 'סיום']
 A & D --> C
`}/>

להוספת תנאים נוספים, נשתמש במילות השמורות `elif` ו `else`.
1. `elif` - ״אחרת אם״.
2. `else` - ״אחרת״.


```python
temperature = 20
if temperature > 30:
 print("its hot today!")
 print("drink water!")
elif temperature < 25:
 print("nice weather")
print("Done")
```
מה שיודפס הפעם זה:
```bash
nice weather
Done
```
> שימוש ב-elif מאפשר לנו לבדוק מספר תנאים כך שברגע שתנאי אחד מתקיים, הקוד המתבצע הוא הקוד בגוף התנאי הזה בלבד.


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

```python
temperature = 20
if temperature > 30:
 print("its hot today!")
 print("drink water!")
elif temperature < 25:
 print("nice weather")
else:
 print(“the temperature is between 25->30”)
print("Done")
```
מה שיודפס הפעם זה:
```bash
the temperature is between 25->30
Done
```

## כעת שאתם מכירים משפטי תנאי, התחילו לבצע את המטלה.

תנאים

courses/python101/lessons/string-manipulations/string-manipulations.md

## על מה נעבור 

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

> תהליך ניתוח מחרוזת נקרא פירסור, ובאנגלית parsing.

## רענון - יצירת מחרוזת
ברוב המוחלט של שפות התכנות ״עטיפה״ של טקסט (לווא דווקא המורכב רק מאותיות) בגרשיים, מסמנת לשפת התכנות להתייחס לטקסט זה כאל **מחרוזת** ולא כאל שם של משתנה או פקודה כלשהי בשפה.
```python
my_first_string = "hello world"
also_string = "Metallica"
also_string2 = "I love the number 7!"
also_string3 = "F"
also_string4 = "123" # please notice that the text "123" does not equal to the number 123!
```
> בפייתון ניתן גם לסמן מחרוזת ע״י עטיפת הטקסט בגרש יחיד.
```python
 my_first_string = 'hello world'
```

> לשיקול המתכנת באיזה סוג גרש (יחיד או כפול) ברצונו להשתמש, אך יש לשמור על אחידות בקוד.
 
## שרשור מחרוזות
בדומה לפעולות החיבור והכפל במספרים, ניתן להשתמש גם באופרטורים אלה על מחרוזות. 
כאשר אנחנו רוצים לשרשר מחרוזות נשתמש באופרטור החיבור (+).
```python
name = 'Henry'
age = '30'
intro_str = 'hello! my name is ' + name + " and i'm " + age + ' years old.' # final_str = 'hello! my name is Henry and i'm 30 years old.'
```
> כאשר רוצים להשתמש בגרש יחיד לסימון מחרוזות אך הטקסט מכיל גרש יחיד כחלק ממילה, לדוגמה `i'm`, יש להקיף את הטקסט עם גרשיים כפולות

## עיצוב מחרוזות (String Formatting)
בפייתון קיימת גישה ״נקייה״ יותר לגבי הדפסת מחרוזות בהם משולבות משתנים (כמו בדוגמה הקודמת) דרך זו קריאה יותר למתכנת ופחות מסורבלת משרשור. 
כדי לעצב מחרוזת, לפני עטיפת הטקסט בגרשיים, יש להוסיף את האות `f`. בכל פעם שנרצה לשלב משתנה לתוך המחרוזת, במקום המיועד נקיף אותו בסוגריים מסולסלות - `{}`
```python
name = 'Henry'
age = '30'
intro_str = f"hello! my name is {name} and i'm {age} years old."
print(intro_str)
```
> בדוגמה זו, כאשר פייתון יבצע את פקודת ההדפסה למסך, המשתנה `name`יוחלף במחרוזת `Henry` והמשתנה `age` יוחלף במחרוזת `30`

## פונקציות מחרוזת מובנות
כל מחרוזת היא אובייקט (עוד על כך בהמשך הקורס). 
זה אומר שיש לה פונקציות מובנות (שיטות) שניתן להכיל אותן רק על מחרוזות. 
פונקציות אלו עוזרות לנו לבצע מניפולציות על המחרוזת, בתהליך הנקרא פירסור (parsing), כדי להכין אותה לעיבוד נוסף. 
על מנת להשתמש בשיטות אלה, נקרא להן ע״י הוספת ״נקודה״ - `.` מיד לאחד סיום המחרוזת (או המשתנה שמייצג את המחרוזת)ואז נכתוב את שם השיטה ונוסיף סוגריים.

 
### lower / upper
פונקציה זו הופכת את כל אותיות המחרוזת לאותיות גדולות או קטנות בהתאמה.

```python
str = 'HeLlO WoRlD'
str_lower = str.lower()
str_upper = str.upper()
print(str_lower)
print(str_upper)
```
תוצאת ההרצה:
```bash
hello world
HELLO WORLD
```

### islower / isupper
בשפות תכנות רבות נהוג שפונקציה אשר מתחילה במילה `is` מחזירה ערך **בוליאני**, כלומר `True` או `False` 
ולכן פונקציות אלה מחזירה האם **כלל** האותיות במחרוזת אותיות גדולות או קטנות בהתאמה.
>פונקציות אלה מתעלמות מתווים שאינם אותיות כמו סימנים מיוחדים (!, @ ,$,*) ומספרים.

```python
str = 'hello 123'
is_str_lower = str.islower()
is_str_upper = str.isupper()
print(is_str_lower)
print(is_str_upper)
print('---')
str2 = 'Henry'
is_str_lower2 = str2.islower()
is_str_upper2 = str2.isupper()
print(is_str_lower2)
print(is_str_upper2)
print('---')
str3 = 'WELCOME!'
is_str_lower3 = str3.islower()
is_str_upper3 = str3.isupper()
print(is_str_lower3)
print(is_str_upper3)
```
תוצאת ההרצה:
```bash
True
False
---
False
False
---
False
True
```

### בדיקת אורך מחרוזת - הפונקציה len
הפונקציה `len` הינה פונקציה מובנית של שפת פייתון ולא רק של האובייקט מחרוזת וניתן להשתמש בה לעוד סוגי אובייקטים נוספים שנכיר בהמשך הקורס. 
כדי לדעת מהו אורך הטקסט, נקרא לפונקציה `len` וכפרמטר, בתוך סוגריים, נעביר לה את המחרוזת (או את המשתנה המייצג את המחרוזת)
הפונקציה מחזירה מספר שלם, המייצג את אורך המחרוזת.
```python
str = 'what is my length?'
str_size = len(str)
print(str_size)
```
תוצאת ההרצה:
```bash
18
```

### המרה למחרוזת - הפונקציה str
בפייתון, ניתן להמיר כל טיפוס בסיסי (מספר שלם, מספר עשרוני ובוליאן) למחרוזת, כלומר לטקסט. 
הפונקציה מחזירה את הערך ממוזר למחרוזת (טקסט)
```python
amount = 28
integer_to_str = f'total is ' + str(amount)
amount += 3.5
float_to_str = f'total is ' + str(amount)
bool_to_str = str(True)
print(integer_to_str)
print(float_to_str)
print(bool_to_str)
```
תוצאת ההרצה:
```bash
total is 28
total is 31.5
True
```

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

> ניתן להימנע מהמרת מספר למחרוזת ע״י שימוש בעיצוב מחרוזות (String Formatting). ע״י שימוש בעיצוב מחרוזות, פייתון ממיר את הערכים שבתוך הסוגריים המסולסלים לטיפוס מחרוזת בשבילנו!
 ```python
 amount = 28
 integer_to_str = f'total is {amount}'
 print(integer_to_str)
 ```
תוצאת ההרצה:
 ```bash
 total is 28
 ```

## טבלת ASCII
כידוע, מחשב שומר נתונים בזיכרון כרצף של ספרות בינאריות (0 ו-1) בזיכרון. 
כאשר אנחנו רוצים לשמור מחרוזת בזיכרון, המחשב מבצע המרה של כל תו במחרוזת למספר שבפועל מספר זה נשמר בזיכרון. 
כאשר אנו נפנה לזיכרון המחשב ונקרא ממנו את הערך שנשמר תתבצע המרה חוזרת לתו ששווה לערך המספר. 
טבלת ascii הינה טבלה שממפה בין תו למספר עשרוני שנשמר בזיכרון המחשב כמספר בינארי. 
טבלת ascii הינה קבועה

### טבלת ascii לדוגמא לחצו על התמונה להגדלה 

 ![קורס פייתון אינטרקטיבי בעברית](/images/ascii_table.png "טבלת אסקי לחצו על התמונה בשביל הגדלה")


> כפי שניתן לראות, הערך של האותיות הגדולות והקטנות באנגלית שונה. כך למשל ערכה של תו a הינו 97 אך ערכו של התו A הינו 65

> טבלת ASCII תקפה רק לאותיות לטיניות. לטובת השפה העברית למשל, המציאו פרוטוקול נוסף שלא נדבר עליו בקורס זה

> עצם המרת מחרוזת לערך מספרי מאפשרת לנו לבצע פעולות מתמטיות על מספרים ולהמירם חזרה למחרוזת

### המרה בין מחרוזת לASCII ולהיפך
כדי לקבל את הערך המספרי של תו כלשהו (לא חייב להיות אות), נשתמש בפונקציה המובנית בשפת פייתון `ord`

```python
a_to_ascii = ord('a')
B_to_ascii = ord('B')
symbol_to_ascii = ord('!')
print(a_to_ascii)
print(B_to_ascii)
print(symbol_to_ascii)
```
print result
```bash
97
66
33
```

כדי להמיר ASCII למחרוזת נשתמש בפונקציה המובנית `chr`, מהמילה character

```python
ascii_to_a = chr(97)
ascii_to_B = chr(66)
ascii_to_symbol = chr(33)
print(ascii_to_a)
print(ascii_to_B)
print(ascii_to_symbol)
```
print result
```bash
a
B
!
```

 

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

נכתוב תוכנה שתבצע את רצף הפעולות הבא:
1. נקבל קלט ממשתמש.
2. נוודא שאכן מדובר באות.
3. כיוון שיש לנו גם אותיות גדולות וגם קטנות נמיר מראש כל אות לאות קטנה וכך נמנע מלתת מענה לכל אחד מהמקרים.
4. נשתמש ב`ord` כדי לחשב את המיקום בטבלה.
5. נחסר את המיקום שקיבלנו מהמיקום של האות הראשונה בא״ב האות `a`.
6. נדפיס את התוצאה.
 
לחצו על `run` ותראו את התוצאה.
<CoveredIframe loading="lazy" src="https://trinket.io/embed/python/ecfd61e25a?runOption=run" width="100%" height="600" frameborder="0" marginwidth="0" marginheight="0" allowfullscreen/>

מחרוזות וטבלת ascii

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

## על מה נעבור 

## מוטיבציה

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

## יצירת רשימה

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

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

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

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

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

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

| elements | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 'a' | 'b' |
|----------|-----|-----|-----|-----|-----|-----|-----|-----|-----|
| index | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |

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

fifth_element = my_first_list[4] # fifth_element = 5
```

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

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

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

last_element = my_first_list[-1] # last_element = True
second_to_last_element = my_first_list[-2] # second_to_last_element = 'b'
```

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

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

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

my_first_sub_list = my_first_list[0:4] # my_first_sub_list = [1, 2, 3, 4]
```

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

ניתן גם לבצע slicing עם אינדקסים שליליים
```python
my_first_list = [1, 2, 3, 4, 5, 6, 7, 'a', 'b', True]
my_second_sub_list = my_first_list[5:-2] # my_second_sub_list = [6, 7, 8, 'a']
my_third_sub_list = my_first_list[-3:-1] # my_third_sub_list = ['a', 'b']
```

כאשר רוצים לבצע חיתוך מאינדקס מסוים ועד סוף הרשימה ניתן להשמיט את האינדקס הסופי בתוך הסוגריים המרובעים
```python
my_first_list = [1, 2, 3, 4, 5, 6, 7, 'a', 'b', True]
my_forth_sub_list = my_first_list[5:] # my_forth_sub_list = [6, 7, 8, 'a', 'b', True]
```

## הוספה לרשימה

כדי להוסיף איבר לרשימה, נשתמש בפוקנציה `append` אותה נפעיל על המשתנה ש״מחזיק״ ברשימה. לפונקציה נעביר את האיבר אותו ברצננו להוסיף לרשימה. 
האיבר יתווסף לסוף הרשימה וגודל הרשימה יגדל ב-1.
```python
some_list = []
some_list.append(2)
print(some_list)
```
```bash
[2]
```
```python
some_list.append(5)
print(some_list)
```
```bash
[2, 5]
```

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

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

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

אפשר גם לחבר רשימות באמצעות האופרטור + 
```python
some_list1 = [1, 2, 3]
some_list2 = [4, 5, 6]
some_list = some_list1 + some_list2
print(some_list)
```
```bash
[1, 2, 3, 4, 5, 6]
```

<LevelTest>
 <question_block>
 <question>
 כעת נתרגל כמה פעולות על רשימה על ידי שימוש בפונקציות שלמדנו וכמה שנפגוש ממש עכשיו.
כלל הפוקנציות שייכות לאובייקט ״רשימה״ וזמינים בשפת פייתון.

הגדירו את המשתנה my_list והכניסו לתוכו את הרשימה הבאה [2, 5, 8, 10, 4, 7, 3, 1]
 </question>
 <answer value={"[1, 3, 7, 4, 10, 8, 5, 2]\n"}/>
 <test value={"print(my_list)"}/>
 </question_block>
 <question_block>
 <question>
מצוין!
עכשיו הוסיפו את המספר 6 לסוף הרשימה
 </question>
 <answer value={"[1, 3, 7, 4, 10, 8, 5, 2, 6]\n"}/>
 <test value={"print(my_list)"}/>
 </question_block>
 <question_block>
 <question>
מצוין!
עכשיו מיחקו את המספר 8 מהרשימה

פעולה זו מתבצעת ע״י הפונקציה remove המופעלת על הרשימה (בדומה לפונקציה append). הפונקציה מקבלת את האיבר אותו ברתצוננו למחוק.
אם ברשימה אין את האיבר המבוקש תקפוץ שגיאה.
 </question>
 <answer value={"[1, 3, 7, 4, 10, 5, 2, 6]\n"}/>
 <test value={"print(my_list)"}/>
 </question_block>
 <question_block>
 <question>
מצוין!
עכשיו מיינו את הרשימה בסדר עולה (המספר הנמוך ביותר יהיה באינדקס 0)

נוכל לעשות זאת בקלות ע״י שימוש בפונקציה sort. הפונקציה sort אינה מחזירה דבר והיא ממיינת את הרשימה המקורית.
 </question>
 <answer value={"[1, 2, 3, 4, 5, 6, 7, 10]\n"}/>
 <test value={"print(my_list)"}/>
 </question_block>
 <question_block>
 <question>
מצוין!
עכשיו הפכו את הסדר של הרשימה כך שהאיבר באינדקס 0 יהיה באינדקס האחרון ברשימה וכך הלאה (תמונת מראה)

נוכל לעשות זאת ע״י שימוש בפונקציה reverse.
 </question>
 <answer value={"[10, 7, 6, 5, 4, 3, 2, 1]\n"}/>
 <test value={"print(my_list)"}/>
 </question_block>
 <question_block>
 <question>
מצוין!
עכשיו הוסיפו את המספר 9 לאינדקס מספר 2 ברשימה (מיקום שלישי ברשימה)
נוכל לעשות זאת ע״י שימוש בפונקציה insert שקבלת שני פרמטרים: הראשון, המיקום בו נרצה להכניס את האיבר והפרמטר השני הוא האיבר אותו נרצה להכניס.
 </question>
 <answer value={"[10, 7, 9, 6, 5, 4, 3, 2, 1]\n"}/>
 <test value={"print(my_list)"}/>
 </question_block>
 <question_block>
 <question>
מצוין!
עכשיו ספרו את מספר החזרות של המספר 5 ברשימה.
נעשה זאת ע״י שימוש בפונקציה count אשר מקבלת כפרמטר את האיבר אותו נרצה לספור. קלטו את התוצאה למשתנה בשם count.
 </question>
 <answer value={"1\n"}/>
 <test value={"print(count)"}/>
 </question_block>
 <question_block>
 <question>
מצוין!
הרחיבו את הרשימה עם המספרים הבאים: 4, 3 ו-11.
 </question>
 <answer value={"[10, 7, 9, 6, 5, 4, 3, 2, 1, 4, 3, 11]\n"}/>
 <test value={"print(my_list)"}/>
 </question_block>
<question_block>
 <question>
מצוין!
שימו לב שיש שלוש דרכים לבצע משימה זו:
1. my_list.append(4) my_list.append(3) my_list.append(11)
2. my_list.extend([4, 3, 11])
3. my_list = my_list + [4, 3, 11] או my_list += [4, 3, 11]

כעת סכמו את כלל איברי הרשימה לתוך המשתנה list_sum.
נעשה זאת ע״י שימוש בפונקציה המובנית sum, אשר מקבלת כפרמטר רשימה.
 </question>
 <answer value={"65\n"}/>
 <test value={"print(list_sum)"}/>
 </question_block>
 <question_block>
 <question>
מצוין!
עכשיו מחקו את כל איברי הרשימה.
נעשה זאת ע״י שימוש בפונקציה clear.
 </question>
 <answer value={"[]\n"}/>
 <test value={"print(my_list)"}/>
 </question_block>
</LevelTest>

<ProjectContent>

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

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

```python
user_command = "click 13A"

print(user_command[:5]) # will print "click"

print(user_command[6:]) # will print "13A"

print(user_command[2]) # will print "i"

print(user_command[-1]) # will print "A"
```

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

```python
command = "click 5B"
parsed_command = command.split(" ")

print(parsed_command[0]) # will print click
print(parsed_command[1]) # will print 5B

```

</ProjectContent>

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

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

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

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

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

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

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

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

<ProjectContent>

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

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

לכן, ניתן גם לקרוא לרשימה דו-מימדית מטריצה (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 

<CoveredIframe loading="lazy" src="https://trinket.io/embed/python/577a2cffbd?runOption=run" width="100%" height="700" frameborder="0" marginwidth="0" marginheight="0" allowfullscreen/>

</ProjectContent>

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

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

```python
some_list = [1, 2, 3]
one, two, three = some_list
print(one)
print(two)
print(three)
```
```bash
1
2
3
```

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

רשימות

## על מה נעבור 

## מוטיבציה

נניח אנחנו רוצים לממש את הלוגיקה הבאה:

<Mermaid chart={`
flowchart RL;
INPUT[/קבל מספר y/]--> A[הגדר x=0];
A --> IF{x מתחלק ב-2 ללא שארית}
IF -- True --> PRINT[הדפס x]
PRINT --> INC[x=x+1]
IF -- False --> INC
INC --> IF_LOOP{x קטן מ y}
IF_LOOP -- True --> IF
IF_LOOP -- False --> DONE[צא מהתוכנית]
`}/>

<HiddenAnswer button="נסו להבין מה מטרת התוכנית, לחצו כאן לעזרה">

קולטים מספר כלשהו `y` ומגדירים את `x` להיות 0. 

1. אם `x` מתחלק ב-2 ללא שארית (כלומר `x` הינו מספר זוגי) - הדפס את `x`.
2. הגדל את `x` ב-1.
3. אם x עדיין קטן מ`y` חזור לשלב 1. אחרת, התקדם לשלב 4.
4. צא מהתוכנית.

התוכנית הנ״ל תדפיס את כל המספרים הזוגיים עד y (לא כולל).
</HiddenAnswer>

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


## לולאת `while`

לולאת `while` מורכבת מהרכיבים הבאים:

1. תנאי הלולאה.
2. גוף הלולאה.

גוף לולאת ה`while` ימשיך להתבצע כל עוד תנאי הלולאה הוא `True`.

דוגמא:
```python
i = 0
my_list = []
while i < 100:
 if i % 10 == 0:
 my_list.append(i)
 i = i + 1
```
<HiddenAnswer button="נסו להבין מה יהיה שמור במשתנה `my_list` ,לחצו כאן לעזרה">
הלולאה תרוץ 100 פעמים (נקרא גם איטרציות) - בכל איטרציה נעלה את `i` ב-1 עד ש-`i` יגיע ל-100. בשלב זה התנאי `i < 100` יחדל מלהתקיים ונצא מהלולאה. 
בכל איטרציה ש-`i` יתחלק ב-10 ללא שארית, נוסיף אותו לרשימה.

נקבל:
```python
my_list = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
```
</HiddenAnswer>

> שימוש בלולאות בדגש על לולאת `while` חושף אותנו למצב בו ייתכן והתוכנית תרוץ לנצח.
> למצב זה קוראים לולאה אינסופית כלומר, מצב בו תנאי ההמשך מתקיים **תמיד** ולכן התוכנה תיתקע.

דוגמה ללולאה אינסופית:
```python
i = 1
while i > 0:
 print("hello world")
```
קל לראות שתנאי ההמשך תמיד יהיה ״אמת״ שכן אנחנו בכלל לא מעדכנים את `i` בגוף הלולאה. 
בשימוש בלולאות while, יש לוודא שאין תרחיש בו אנחנו נגיע למצב של לולאה אינסופית.


## לולאת `for`

> בשלב זה חשוב לציין, קיימים סוגים שונים של לולאות מתוך נוחות. 
> כל מה שניתן להשיג עם לולאת `for` ניתן גם להשיג עם לולאת `while` וכמובן להפך.

לולאת `for` מורכבת מהרכיבים הבאים:

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

```python
for i in [1, 2, 3, 4]:
 print(i)
```

<HiddenAnswer button="נסו להבין מה מטרת התוכנית, לחצו כאן לעזרה">

```bash
1
2
3
4
```

</HiddenAnswer>

### פונקציית `range`

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

דוגמא:

```python
for i in range(10, 13):
 print(f"hello-{i}")
```

<HiddenAnswer button="נסו להבין מה מטרת התוכנית, לחצו כאן לעזרה">
```bash
hello-10
hello-11
hello-12
```
</HiddenAnswer>



### פונקציית `enumerate`

לפעמים אנחנו לא רוצים רק ״לגעת״ בכל איברי הרצף אלא גם לקבל גישה למיקומים שלהם ברשימה. 
כדי לעשות זאת נשתמש בפונקציה `enumerate`. .
פונקציה זו מייצרת רצף ״חדש״ של זוגות של איברים כאשר האיבר הראשון בזוג הוא index המציין את מיקום האיבר ברצף והאיבר השני הוא איבר עצמו. 

> שימו לב שאם אנו לא מעוניינים להשתמש באיברים שיש ברצף, נהוג להגדיר את משתנה הרצף בשם `_`.

דוגמה:

```python
my_mixed_list = [[10, 20, "a", "b", "c"], [1, 2, 3, 4], ["a", "a", "a"]]
for idx, _ in my_mixed_list:
 for inner_idx, j in my_mixed_list[idx]:
 if j == "a":
 my_mixed_list[idx][inner_idx] = 999
print(my_mixed_list)
```

<HiddenAnswer button="נסו להבין מה מטרת התוכנית, לחצו כאן לעזרה">
```bash
[[10, 20, 999, "b", "c"], [1, 2, 3, 4], [999, 999, 999]]
```
</HiddenAnswer>

## פקודות יחודיות ללולאות

### break

המילה השמורה `break` מציינת עצירה ויציאה מיידית מהלולאה. 
אחד השימושים העיקריים בפקודה הוא חיפוש ערך ברשימה- כאשר מצאנו את הערך, אין טעם להמשיך לעבור על יתר איברי הרשימה 
דוגמה:

```python
my_list = [1, 23, 99, 42, ..., 365, ..., 22031992]
for number in my_list:
 if number == 42:
 print('We have found the answer to life, the universe, and everything!')
 break
```

### continue

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

```python
num = 1
while num <= 10:
 if num % 3 == 0:
 num += 1
 continue # Skip numbers divisible by 3
 print(num)
 num += 1
```
בדוגמה זו, אם המספר זוגי, ערכו יעלה ב-1 ולא יודפס. אם המספר אי-זוגי, המספר יודפס ואז ערכו יעלה ב-1.

> שימוש ב-`continue` כאשר הלולאה באיטרציה האחרונה יוביל ליציאה מהלולאה

אם כי לעיתים שימוש בפקודה `continue` בתוך ללולאה עשוי לפשט את הקוד ולעשות אותו יותר קריא, תמיד אפשר להימנע משימוש בה. בדר״כ ע״י להפוך את התנאי שמוביל לביצוע הפקודה. 
לדוגמה:

```python
num = 1
while num <= 10:
 if not num % 3 == 0:
 print(num)
 num += 1
```

שימו לב שהפקודות `break` ו-`continue` חלות אך ורק על הלולאות בהן הן ״חיות״.
במקרה של לולאות מקוננות (לולאה בתוך לולאה), אם אחת מהפקודות תופיע בלולאה הפנימית, היא תחול רק על הלולאה הפנימית בעוד הלולאה החיצונית תמשיך לרוץ כרגיל 
דוגמה:

 ```python
for i in range(3):
 for j in range(3):
 if j == 1:
 break # This breaks the inner loop
 print(i, j)

for i in range(3):
 for j in range(3):
 if j == 1:
 continue # This continues to the next iteration of the inner loop
 print(i, j)
```

## בואו נצייר מלבן

נניח אנחנו רוצים להדפיס מלבן למסך בגודל כלשהו שנקבל מהמשתמש. 
דוגמה עבור הגודל 4*2 התוכנה צריכה להדפיס למסך: (מלבן בגובה 2 כוכביות ורוחב 4 כוכביות)
```python
****
****
```
דוגמה עבור 5*3 (מלבן בגובה 3 כוכביות ורוחב 5 כוכביות

```python
*****
* *
*****
```

 מלאו את הקוד הנכון במקום `???`.

<CoveredIframe loading="lazy" src="https://trinket.io/embed/python/aa131a32e1?runOption=run" width="100%" height="300" frameborder="0" marginwidth="0" marginheight="0" allowfullscreen/>

> התו `n\` מייצג הורדת שורה
> כאשר משרשרים אותה למחרוזת בעת הדפסה פייתון יבצע ירידת שורה.

<HiddenAnswer button="להצגת הפתרון לחצו כאן.">

```python
rows = int(input("give me rows:"))
columns = int(input("give me columns:"))

result = "*" * columns + "\n"
for _ in range(rows - 2):
 result = result + "*" + " " *(columns-2) + "*" + "\n"

result = result + "*" * columns + "\n"

print(result)

```
</HiddenAnswer>

## תרגול נוסף

<LevelTest>
 <question_block>
 <question>
 אתגר 1 מתוך 3. 
כתבו פונקציה is_palindrome אשר מקבלת כפרמטר מחרוזת ומחזירה True אם המחרוזת פלינדרום, אחרת הפונקציה תחזיר False. 
מה זה פלינדרום (Palindrome)? מחרוזת אשר אפשר לקרוא אותה משני הכיוונים באותה צורה. המחרוזות הבאות הן פלינדרום - level, radar, abba, race car, 12321. 
גם בעברית קיימים פלינדרומים - ״ילד כותב בתוך דלי״. 
הכוונה: התעלמו מרווחים ועשו שימוש בלולאת for על אורך המחרוזת.
 </question>
 <answer value={"True\n"}/>
 <test value={"print(is_palindrome('level'))"}/>
 <answer value={"True\n"}/>
 <test value={"print(is_palindrome('abba'))"}/>
 <answer value={"True\n"}/>
 <test value={"print(is_palindrome('race car'))"}/>
 <answer value={"False\n"}/>
 <test value={"print(is_palindrome('amit-michael'))"}/>
 </question_block>
 <question_block>
 <question>
עבודה טובה!
אתגר 2 מתוך 3.
כתבו פונקציה drop_duplicates אשר מקבלת כפרמטר רשימה של מספרים ומדפיסה רק את המספרים הייחודים הנמצאים ברשימה.
לדוגמה, עבור הרשימה [1, 1, 2, 2, 3, 4, 5, 5] הפונקציה תדפיס [1, 2, 3, 4, 5].
הכוונה: השתמשו ברשימה נוספת בה שמרו את המספרים שכבר ״ראיתם״.
 </question>
 <answer value={"[1, 2, 3, 4, 5]\n"}/>
 <test value={"drop_duplicates([1, 1, 2, 2, 3, 4, 5, 5])"}/>
 <answer value={"[2, 3, 9, 2]\n"}/>
 <test value={"drop_duplicates([2, 2, 3, 9, 2])"}/>
 <answer value={"[2]\n"}/>
 <test value={"drop_duplicates([2])"}/>
 <answer value={"[1]\n"}/>
 <test value={"drop_duplicates([1, 1])"}/>
 </question_block>
 <question_block>
 <question>
מצוין!
אתגר 3 מתוך 3
כתבו פונקציה count_vowels אשר מקבלת כפרמטר מחרוזת ומחזירה כמה פעמים האותיות a, e, i, o, u מופיעות במחרוזת.
המחרוזת עשויה להכיל אותיות גדולות וקטנות ועל הפונקציה לספור אותיות גדולות וקטנות כאחד.
 </question>
 <answer value={"3\n"}/>
 <test value={"print(count_vowels('Hello, World!'))"}/>
 <answer value={"6\n"}/>
 <test value={"print(count_vowels('Python is AwesOmE'))"}/>
 <answer value={"9\n"}/>
 <test value={"print(count_vowels('abra KADABRA ALAkazam'))"}/>
 <answer value={"1\n"}/>
 <test value={"print(count_vowels('u'))"}/>
 </question_block>
</LevelTest>

לולאות for ולולאות while בפייתון

# מבוא ל-Tuples בפייתון

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

## מה זה Tuple?

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

### איך יוצרים Tuple?

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

```python
my_tuple = (1, 2, 3)
```


### מאפיינים של Tuples

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

### דוגמאות לשימוש ב-Tuples

```python
# הגדרת טפל המכיל מספרים
numbers = (1, 2, 3, 4, 5)

# גישה לערך לפי אינדקס
print(numbers[0]) # פלט: 1

# טפל המכיל סוגי נתונים שונים
mixed = (1, "hello", 3.14, True)

print(mixed[1]) # פלט: hello
```


### למה להשתמש ב-Tuples?

Tuples הם מבנה נתונים יעיל ונוח במצבים שבהם יש צורך ברצף של ערכים שלא אמורים להשתנות במהלך הריצה של התוכנית. בנוסף, הם מהירים יותר מרשימות מכיוון שאין צורך לנהל את שינויי הערכים בתוכם.

### יתרונות וחסרונות של Tuples

**יתרונות:**
- בלתי ניתנים לשינוי: מבטיחים שלמות הנתונים.
- מהירים יותר מרשימות לקריאה.

**חסרונות:**
- בלתי ניתנים לשינוי: לא ניתן להוסיף או להסיר ערכים לאחר ההגדרה.


## תרגול

<LevelTest>
 <question_block>
 <question>
 הגדירו Tuple בשם `my_tuple` המכיל את המספרים 10, 20, ו-30.
 </question>
 <answer value={"(10, 20, 30)\n"}/>
 <test value={"print(my_tuple)"}/>
 </question_block>
 <question_block>
 <question>
 גשו לערך השני ב-Tuple שהגדרתם קודם והדפיסו אותו.
 </question>
 <answer value={"20\n"}/>
 <test value={"print(my_tuple[1])"}/>
 </question_block>
 <question_block>
 <question>
 הגדירו Tuple בשם `mixed_tuple` המכיל את הערכים הבאים: 1, hello', 3.14, True'.
 </question>
 <answer value={"('hello', 3.14, True, 1)\n"}/>
 <test value={"print(mixed_tuple)"}/>
 </question_block>
 <question_block>
 <question>
 גשו לערך השלישי ב-Tuple שהגדרתם ושמרו אותו במשתנה חדש בשם `third_value`.
 </question>
 <answer value={"True\n"}/>
 <test value={"print(third_value)"}/>
 </question_block>
</LevelTest>

בהצלחה!

פייתון Tuples (טאפלים)

# על מה נעבור 

# מבוא למילונים (Dictionaries) בפייתון

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

## מה זה מילון?

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

### איך יוצרים מילון?

כדי ליצור מילון, יש להשתמש בסוגריים מסולסלים `{}` ולהפריד בין המפתחות לערכים באמצעות נקודתיים `:`. ניתן גם ליצור מילון באמצעות הפונקציה `dict`.

```python
# יצירת מילון ריק
my_dict = {}

# יצירת מילון עם ערכים
my_dict = {
 "name": "John",
 "age": 30,
 "city": "New York"
}

# יצירת מילון באמצעות הפונקציה dict()
my_dict = dict(name="John", age=30, city="New York")
```

### גישה לערכים במילון

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

```python
my_dict = {
 "name": "John",
 "age": 30,
 "city": "New York"
}

# גישה לערך באמצעות מפתח
print(my_dict["name"]) # פלט: John
```


### גישה לערכים במילון

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

```python
my_dict = {
 "name": "John",
 "age": 30,
 "city": "New York"
}

# גישה לערך באמצעות מפתח
print(my_dict["name"]) # פלט: John
```

אם ננסה לגשת למפתח שאינו קיים במילון, תתקבל שגיאת `KeyError`. כדי להימנע משגיאה זו, ניתן להשתמש במתודה `get`, אשר תחזיר `None` אם המפתח לא קיים, או ערך ברירת מחדל שנגדיר.
```python
print(my_dict.get("name")) # פלט: John
print(my_dict.get("country", "USA")) # פלט: USA
```




### הוספה ועדכון של ערכים במילון

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

```python
my_dict = {
 "name": "John",
 "age": 30
}

# הוספת ערך חדש
my_dict["city"] = "New York"

# עדכון ערך קיים
my_dict["age"] = 31

print(my_dict)
# פלט: {'name': 'John', 'age': 31, 'city': 'New York'}
```


### מחיקת ערכים מהמילון

כדי למחוק ערך ממילון, ניתן להשתמש במילת המפתח `del` או במתודה `pop`.

```python
my_dict = {
 "name": "John",
 "age": 30,
 "city": "New York"
}

# מחיקת ערך באמצעות del
del my_dict["age"]

# מחיקת ערך באמצעות pop()
city = my_dict.pop("city")

print(my_dict) # פלט: {'name': 'John'}
print(city) # פלט: New York
```





### איטרציה על מילונים

ניתן לעבור על כל המפתחות, הערכים, או זוגות המפתח-ערך במילון באמצעות לולאת `for`.

```python
my_dict = {
 "name": "John",
 "age": 30,
 "city": "New York"
}

# מעבר על המפתחות
for key in my_dict:
 print(key)

# מעבר על הערכים
for value in my_dict.values():
 print(value)

# מעבר על זוגות המפתח-ערך
for key, value in my_dict.items():
 print(key, value)
```


### יתרונות וחסרונות של מילונים

**יתרונות:**
- גישה מהירה לערכים באמצעות מפתחות.
- גמישות באחסון סוגי נתונים שונים כערכים.

**חסרונות:**
- תופסים יותר זיכרון בהשוואה לרשימות.
- מפתחות חייבים להיות ייחודיים ובלתי ניתנים לשינוי.


## תרגול פייתון אונליין 

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

<LevelTest>
 <question_block>
 <question>
 הגדירו מילון בשם `person` המכיל את המפתחות הבאים: "name" עם הערך "age", "Alice" עם הערך 28, ו-"city" עם הערך "London".
 </question>
 <answer value={"{'name': 'Alice', 'age': 28, 'city': 'London'}\n"}/>
 <test value={"print(person)"}/>
 </question_block>
<question_block>
 <question>
 הוסיפו את המפתח "country" עם הערך "UK" למילון `person`.
 </question>
 <answer value={"{'name': 'Alice', 'age': 28, 'city': 'London', 'country': 'UK'}\n"}/>
 <test value={"print(person)"}/>
 </question_block>
<question_block>
 <question>
 עדכנו את הערך של המפתח "age" ל-29 במילון `person`.
 </question>
 <answer value={"{'name': 'Alice', 'age': 29, 'city': 'London', 'country': 'UK'}\n"}/>
 <test value={"print(person)"}/>
 </question_block>
<question_block>
 <question>
 מחקו את המפתח "city" מהמילון `person`.
 </question>
 <answer value={"{'name': 'Alice', 'age': 29, 'country': 'UK'}\n"}/>
 <test value={"print(person)"}/>
 </question_block>
</LevelTest>

בהצלחה!

פייתון מילונים

# על מה נעבור 

# פייתון גנרטורים - מבוא

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

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

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

```python
def count_up_to(max_val):
 n = 0
 while n < max_val:
 yield n
 n += 1

counter = count_up_to(3)
print(next(counter)) # 0
print(next(counter)) # 1
print(next(counter)) # 2
print(next(counter)) # StopIteration
```

בדוגמה זו, `count_up_to` היא גנרטור שמחזיר ערכים עוקבים מ-0 עד הערך המקסימלי שהוגדר. בכל פעם שאנו קוראים ל-`next(counter)`, הגנרטור ממשיך את הריצה שלו מהנקודה האחרונה שבה הופסקה.

<LevelTest>
 <question_block>
 <question>
 הגדירו גנרטור בשם `my_range` שמקבל שני ערכים `start` ו-`end`, והוא מחזיר את הערכים מ-`start` עד `end-1` (כולל `start` אך לא כולל `end`), בדומה לפונקציה `range` בפייתון.
 </question>
 <answer value={"[0, 1, 2, 3, 4]\n"}/>
 <test>
 ```python
 gen = my_range(0, 5)
 l = []
 for i in gen:
 l.append(i)
 print(l)
 ```
 </test>
 </question_block>
</LevelTest>

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

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


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

# פייתון גנרטורים - דוגמאות נוספות

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

## דוגמה 1: מחולל פיבונאצ׳י (Fibonanci Generator)

סדרת Fibonacci היא סדרה חשובה ומעניינת במתמטיקה. כל מספר בסדרה הוא סכום שני המספרים הקודמים, החל מ-0 ו-1. הסדרה נראית כך: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ...

נכתוב גנרטור שמחזיר את ערכי סדרת פיבונאצ׳י:

```python
def fibonacci():
 a, b = 0, 1
 while True:
 yield a
 a, b = b, a + b
```

שימו לב שהגנרטור "זוכר" את הערכים הקודמים של `a` ו-`b` בכל פעם שהוא נקרא, ובאמצעות הקוד `a, b = b, a + b` אנו מחשבים את הערך הבא בסדרה.

שימו לב ש`fibonacci` יכול לרוץ לנצח (תמיד יש את המספר הבא) על כן אי אפשר פשוט להחליף את `fibonacci` ברשימה רגילה.

<LevelTest>
 <question_block>
 <question>
 הפעילו את הגנרטור `fibonacci`, והכניסו את 10 הערכים הראשונים לרשימה שתישמר במשתנה `result_list`.
 שימו לב ש
 ```python
 list(fibonacci())
 ```
 תיכשל כי במקרה הנוכחי הרשימה היא אינסופית וזה עלול להקריס לנו את המחשב.
 </question>
 <initialCode>
 ```python
 # DONT TOUCH THIS CODE
 def fibonacci():
 a, b = 0, 1
 while True:
 yield a
 a, b = b, a + b
 # ---------------------
 ```
 </initialCode>
 <answer value={"[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]\n"}/>
 <test>
 ```python
 print(result_list)
 ```
 </test>
 </question_block>
</LevelTest>

## דוגמה 2: מחולל משתנים אקראיים (Random Variable Generator)

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

```python
import random

def random_variable(distribution):
 while True:
 yield random.choice(distribution)
```

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

<LevelTest>
 <question_block>
 <question>
 בדומה לדוגמא הגדירו גנרטור `random_variable` זמנו אותו עם ההתפלגות `[1, 2, 3, 4, 5]`, ושמרו את 10 התוצאות הראשונות ברשימה בשם `result_list`.
 </question>
 <answer value={"True\n"}/>
 <test>
 ```python
 res = True if len(result_list) == 10 else False
 for i in result_list:
 if i not in [1, 2, 3, 4, 5]:
 res = False
 break
 r = random_variable([1, 2, 3, 4, 5])
 res = res and [next(r) for i in range(10)] != result_list
 print(res)
 ```
 </test>
 </question_block>
</LevelTest>

## דוגמה 3: מחולל ערכים פרימיטיביים (Primitive Value Generator)

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

```python
def integers(start, stop, step=1):
 value = start
 while value < stop:
 yield value
 value += step

def floats(start, stop, step=0.1):
 value = start
 while value < stop:
 yield value
 value += step

def strings(start, stop, step=1):
 current = start
 while ord(current) < ord(stop):
 yield current
 current = chr(ord(current) + step)
```

הגנרטורים `integers`, `floats`, ו-`strings` מחזירים ערכים שלמים, ממשיים ומחרוזות, בהתאמה, בתחום הערכים שהוגדר. הם משתמשים בלולאה `while` ובמילה השמורה `yield` כדי להחזיר ערכים חדשים בכל פעם שהם נקראים.

<LevelTest>
 <question_block>
 <question>
 יצרו גנרטור `integers` עם הערכים מ-1 עד 10, שימרו את 5 הערכים הראשונים ב`my_list`.
 </question>
 <answer value={"[1, 2, 3, 4, 5]\n"}/>
 <test>
 ```python
 print(my_list)
 ```
 </test>
 </question_block>
 <question_block>
 <question>
 יצרו גנרטור `floats` עם הערכים מ-0.0 עד 1.0, שימרו את 3 הערכים הראשונים ב`my_list`.
 </question>
 <answer value={"[0.0, 0.1, 0.2]\n"}/>
 <test>
 ```python
 print(my_list)
 ```
 </test>
 </question_block>
 <question_block>
 <question>
 יצרו גנרטור `strings` עם המחרוזות מ-'a' עד 'f', ושימרו את 2 הערכים הראשונים ב`my_list`.
 </question>
 <answer value={"['a', 'b']\n"}/>
 <test>
 ```python
 print(my_list)
 ```
 </test>
 </question_block>
</LevelTest>

## דוגמה 4: גנרטור למעבר על קבצים גדולים (File Iterator Generator)

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

```python
def file_iterator(file_path):
 with open(file_path, 'r') as file:
 for line in file:
 yield line.strip()
```

הגנרטור `file_iterator` מקבל את נתיב הקובץ ומחזיר את כל השורות בקובץ, אחת אחר השנייה. הוא עושה זאת באמצעות לולאה `for` על הקובץ הפתוח, ומחזיר כל שורה באמצעות `yield`.

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

מדריכים