1

מבוא ויסודות

Intro & Basics

🎯 מטרות הלמידה

  • הבנת מהות פייתון כשפה מפורשת (Interpreted)
  • הגדרת משתנים וטיפוסי נתונים בסיסיים (int, float, str, bool)
  • שימוש באופרטורים חשבוניים והשמה
  • המרה בין טיפוסים (Casting) עם int(), float(), str()
  • קלט ופלט עם input() ו-print()
  • תנאים: if-elif-else ואופרטורים לוגיים

1.1מבוא לפייתון

🐍 מהי פייתון?

פייתון היא שפת תכנות מפורשת (Interpreted) ו-High-level שמדגישה קריאות קוד.

היסטוריה קצרה:

  • 1991 - גרסה ראשונה פורסמה על ידי Guido van Rossum
  • 2000 - Python 2.0 עם List Comprehensions
  • 2008 - Python 3.0 (שינויים משמעותיים)
  • אנחנו משתמשים בגרסה 3.8+

למה פייתון?

  • 🌍 עובדת על כל פלטפורמה (Windows, Mac, Linux)
  • 📚 תחביר פשוט דמוי אנגלית
  • ⚡ פחות שורות קוד מרוב השפות
  • 🔄 הרצה מיידית - אין צורך בקומפילציה
  • 📦 מעל 530,000 חבילות זמינות ב-PyPI
💡 טיפ: פייתון יכולה לשמש לפיתוח ווב, Machine Learning, אוטומציה, ניתוח נתונים, ועוד!

1.2משתנים וטיפוסי נתונים

📦 מה זה משתנה?

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

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

  • אין צורך להצהיר על סוג המשתנה מראש
  • משתנה יכול לשנות טיפוס במהלך הריצה
  • כתיבת קוד מהירה יותר
# דוגמאות להגדרת משתנים
x = 5           # int - מספר שלם
x = "שלום"      # עכשיו x הוא str בלי בעיה!

טיפוסים בסיסיים (Primitive Types):

טיפוסדוגמהתיאורהערות
intage = 25מספר שלםגודל ללא הגבלה!
floatprice = 19.99מספר עשרונידיוק מוגבל
strname = 'דני'מחרוזת טקסטגרשיים בודדים או כפולים
boolis_valid = Trueערך בוליאניTrue או False בלבד
complexc = 3+4jמספר מרוכבחלק מדמיון עם j

בדיקת טיפוס עם type():

x = 5
print(type(x))   # 

y = "Hello"
print(type(y))   # 

z = 3.14
print(type(z))   # 
⚠️ נקודה חשובה: בפייתון, True שווה ל-1 ו-False שווה ל-0 בפעולות חשבוניות!
print(True + True)   # 2
print(False * 5)     # 0
print(1 + True)      # 2

1.3המרות טיפוסים (Casting)

🔄 למה צריך המרות?

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

פונקציות המרה:

פונקציהמה עושהדוגמהתוצאה
int()המרה למספר שלםint("42")42
int()חיתוך חלק עשרוניint(3.9)3
float()המרה לעשרוניfloat("3.14")3.14
float()מספר שלם לעשרוניfloat(5)5.0
str()המרה למחרוזתstr(123)"123"
bool()המרה לבוליאניbool(0)False
# דוגמה מעשית - קלט מספרי
age_str = input("בן כמה אתה? ")  # מחזיר מחרוזת!
age = int(age_str)                # המרה למספר
next_year = age + 1               # עכשיו אפשר לחשב

# אפשר גם בשורה אחת:
age = int(input("בן כמה אתה? "))
🚨 מלכודת! המרה של מחרוזת לא-מספרית תגרום לשגיאה:
int("hello")   # ValueError: invalid literal for int()
int("3.14")    # ValueError - אי אפשר ישירות!
int(float("3.14"))  # 3 - עובד!

המרה לבוליאני - כללים חשובים:

  • כמעט כל ערך ממיר ל-True
  • ערכים שממירים ל-False: 0, 0.0, "", [], {}, None
print(bool(0))      # False
print(bool(""))     # False
print(bool(1))      # True
print(bool("hi"))   # True
print(bool(-5))     # True (גם שלילי!)

1.4אופרטורים חשבוניים

🔢 פעולות מתמטיות

אופרטורפעולהדוגמהתוצאה
+חיבור5 + 38
-חיסור5 - 32
*כפל5 * 315
/חילוק5 / 22.5
//חילוק שלם (floor)5 // 22
%מודולו (שארית)5 % 21
**חזקה5 ** 225

חילוק שלם vs חילוק רגיל:

print(7 / 2)    # 3.5 - תמיד מחזיר float
print(7 // 2)   # 3   - מעגל למטה (floor)
print(-7 // 2)  # -4  - שים לב! מעגל למטה, לא לכיוון האפס

שימושים נפוצים במודולו:

# בדיקת זוגיות
if num % 2 == 0:
    print("מספר זוגי")

# חילוץ ספרה אחרונה
last_digit = 1234 % 10  # 4

# חילוץ כל הספרות
n = 852
while n > 0:
    digit = n % 10    # ספרה אחרונה
    n = n // 10       # הסר ספרה אחרונה
    print(digit)

אופרטורי השמה מקוצרים:

מקוצרשווה לדוגמה
x += 5x = x + 5הוספה
x -= 3x = x - 3חיסור
x *= 2x = x * 2כפל
x /= 4x = x / 4חילוק
x //= 2x = x // 2חילוק שלם
x %= 3x = x % 3שארית
x **= 2x = x ** 2חזקה

1.5קלט ופלט - input() ו-print()

🖨️ פלט - print()

הפונקציה print() מדפיסה ערכים למסך:

# פלט בסיסי
print('Hello World')         # Hello World
print('A', 'B', 'C')         # A B C (רווח אוטומטי בין ארגומנטים)

פרמטרים מתקדמים של print:

פרמטרברירת מחדלתפקיד
sep" " (רווח)מפריד בין ארגומנטים
end"\n" (שורה חדשה)מה להדפיס בסוף
# שינוי מפריד
print('A', 'B', 'C', sep='-')     # A-B-C
print('A', 'B', 'C', sep='***')   # A***B***C

# שינוי סוף שורה
print('Loading', end='...')  # Loading... (בלי ירידת שורה)
print('Done!')               # ימשיך באותה שורה: Loading...Done!

# שילוב
print(1, 2, 3, sep='|', end='!')
print('X')                   # 1|2|3!X

⌨️ קלט - input()

הפונקציה input() עוצרת את התוכנית ומחכה לקלט מהמשתמש:

name = input('מה שמך? ')
print('שלום', name)
⚠️ חשוב לזכור: input() תמיד מחזיר מחרוזת!
# ❌ שגיאה נפוצה
age = input('בן כמה אתה? ')  # age הוא מחרוזת!
next_year = age + 1           # TypeError!

# ✅ הפתרון - המרה
age = int(input('בן כמה אתה? '))
next_year = age + 1           # עובד!

סוגי המרות קלט:

name = input('שם: ')              # נשאר מחרוזת
age = int(input('גיל: '))         # מספר שלם
price = float(input('מחיר: '))    # מספר עשרוני

1.6תנאים - if/elif/else

🔀 בקרת זרימה

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

אופרטורי השוואה:

אופרטורמשמעותדוגמה
==שווה לx == 5
!=שונה מx != 5
>גדול מx > 5
<קטן מx < 5
>=גדול או שווהx >= 5
<=קטן או שווהx <= 5

אופרטורים לוגיים:

אופרטורמשמעותדוגמה
andוגם (שניהם נכונים)x > 0 and x < 10
orאו (לפחות אחד)x < 0 or x > 10
notהפוךnot x == 5

מבנה תנאי בסיסי:

age = int(input('הכנס גיל: '))

if age < 18:
    print('ילד/נער')      # הזחה חובה!
elif age < 30:
    print('צעיר')
elif age < 65:
    print('מבוגר')
else:
    print('אזרח ותיק')
💡 שים לב: ברגע שתנאי אחד מתקיים, שאר הענפים לא נבדקים!

תנאים מקוננים:

x = 41
if x > 10:
    print('מעל 10')
    if x > 20:
        print('וגם מעל 20!')
    else:
        print('אבל לא מעל 20')

השוואת טווחים בסגנון פייתוני:

# במקום:
if age >= 18 and age < 30:
    print('צעיר')

# אפשר לכתוב:
if 18 <= age < 30:
    print('צעיר')  # יותר קריא!

שאלות תרגול

5 שאלות בנושא זה

התחל תרגול →