פונקציות ולולאות

🔧 מה זה פונקציה?

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

תחביר בסיסי:

def function_name(param1, param2):
    # גוף הפונקציה
    return result

דוגמאות:

# פונקציה פשוטה ללא פרמטרים
def say_hello():
    print("Hello from a function!")

# פונקציה עם פרמטרים ו-return
def multiply(x, y):
    z = x * y
    return z

# קריאה לפונקציות
say_hello()           # מדפיס Hello...
result = multiply(3, 4)  # result = 12

• print() - מדפיס למסך, לא מחזיר ערך
• return - מחזיר ערך שאפשר להשתמש בו

def with_print(a, b):
    print(a + b)    # רק מדפיס

def with_return(a, b):
    return a + b    # מחזיר תוצאה

x = with_print(2, 3)   # מדפיס 5, x = None!
y = with_return(2, 3)  # y = 5

def calc(a, b):
    res = a + b
    print(res)       # מדפיס 5

x = calc(2, 3)
print(x)             # מדפיס None!

📥 פרמטרים

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

ערכי ברירת מחדל:

def power(x, y=2):     # y=2 הוא ברירת מחדל
    return x ** y

print(power(3, 4))     # 81 (3^4)
print(power(5))        # 25 (5^2) - השתמש בברירת מחדל

Keyword Arguments:

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

def greet(name, greeting="שלום"):
    print(f"{greeting}, {name}!")

greet("דני")                    # שלום, דני!
greet("דני", "בוקר טוב")        # בוקר טוב, דני!
greet(greeting="ערב טוב", name="יוסי")  # ערב טוב, יוסי!

החזרת ערכים מרובים:

def get_name():
    first = input('שם פרטי: ')
    last = input('שם משפחה: ')
    return first, last    # מחזיר tuple

# שימוש:
first_name, last_name = get_name()

החזרת None לציון שגיאה:

def divide(num1, num2):
    if num2 == 0:
        return None    # לא ניתן לחלק ב-0
    return num1 / num2

result = divide(10, 0)
if result is None:
    print("שגיאה: חלוקה באפס")

🌍 Scope - טווח משתנים

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

משתנה לוקאלי:

def my_func():
    x = 10        # משתנה לוקאלי
    print(x)

my_func()         # מדפיס 10
print(x)          # שגיאה! x לא קיים פה

משתנה גלובלי:

x = 10            # משתנה גלובלי

def read_global():
    print(x)      # קורא את הגלובלי

def create_local():
    x = 5         # יוצר משתנה לוקאלי חדש!
    print(x)      # מדפיס 5

read_global()     # 10
create_local()    # 5
print(x)          # 10 - הגלובלי לא השתנה!

x = 10

def my_func(y):
    x = 2              # משתנה לוקאלי חדש!
    return x * y

res = my_func(3)       # res = 6
print(res + x)         # 6 + 10 = 16

שינוי משתנה גלובלי מתוך פונקציה:

counter = 0

def increment():
    global counter     # מכריז שרוצים את הגלובלי
    counter += 1

increment()
increment()
print(counter)         # 2

קבועים גלובליים (Convention):

VAT = 0.17             # שם באותיות גדולות = קבוע

def calculate_price(base_price):
    return base_price * (1 + VAT)

🔄 לולאת while

לולאה שממשיכה כל עוד התנאי מתקיים:

count = 0
while count < 5:
    print(count)
    count += 1        # חשוב! אחרת לולאה אינסופית

break - יציאה מהלולאה:

while True:           # לולאה "אינסופית"
    user_input = input('הכנס מספר (0 ליציאה): ')
    if user_input == '0':
        break         # יוצא מהלולאה
    print(f'הזנת: {user_input}')

continue - דילוג לאיטרציה הבאה:

num = 0
while num < 10:
    num += 1
    if num % 2 == 0:  # אם זוגי
        continue      # דלג להמשך
    print(num)        # מדפיס רק אי-זוגיים: 1,3,5,7,9

else בלולאה - מתבצע רק אם הלולאה לא נעצרה עם break:

val = 0
for i in range(1, 4):
    if i == 2:
        break
    val += i
else:
    val = 10         # לא יתבצע כי היה break!

print(val)           # 1 (רק i=1 הוסף לפני הbreak)

🔢 לולאת for

לולאה שעוברת על כל איבר ברצף (רשימה, מחרוזת, range וכו'):

# על רשימה
for fruit in ['תפוח', 'בננה', 'תפוז']:
    print(fruit)

# על מחרוזת
for char in 'Hello':
    print(char)

פונקציית range():

range(end)              # 0, 1, 2, ..., end-1
range(start, end)       # start, start+1, ..., end-1
range(start, end, step) # start, start+step, ..., עד end

דוגמאות range:

# range(5) → 0, 1, 2, 3, 4
for i in range(5):
    print(i)

# range(2, 6) → 2, 3, 4, 5
for i in range(2, 6):
    print(i)

# range(10, 0, -2) → 10, 8, 6, 4, 2
for i in range(10, 0, -2):
    print(i)

# כמה פעמים תרוץ הלולאה?
for i in range(10, 2, -3):
    count += 1
# i = 10, 7, 4 → 3 פעמים!

לולאות מקוננות:

rows = 3
cols = 4
for r in range(rows):
    for c in range(cols):
        print('*', end='')
    print()   # ירידת שורה אחרי כל שורה

# פלט:
# ****
# ****
# ****