מבוא ויסודות

🐍 מהי פייתון?

פייתון היא שפת תכנות מפורשת (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

📦 מה זה משתנה?

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

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

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

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

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

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

x = 5
print(type(x))   # 

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

z = 3.14
print(type(z))   # 

print(True + True)   # 2
print(False * 5)     # 0
print(1 + True)      # 2

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

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

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

# דוגמה מעשית - קלט מספרי
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 (גם שלילי!)

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

חילוק שלם 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)

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

🖨️ פלט - print()

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

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

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

# שינוי מפריד
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)

# ❌ שגיאה נפוצה
age = input('בן כמה אתה? ')  # age הוא מחרוזת!
next_year = age + 1           # TypeError!

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

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

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

🔀 בקרת זרימה

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

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

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

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

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('צעיר')  # יותר קריא!