אופרטורים ב-Python: אריתמטיים, השוואה, לוגיים, שייכות וזהות

אופרטורים הם פשוט סימנים לפעולות

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

נעבור על הקטגוריות העיקריות אחת אחת.

אופרטורים אריתמטיים

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

print(10 + 3)   # 13
print(10 - 3)   # 7
print(10 * 3)   # 30
print(10 / 3)   # 3.3333333...: / תמיד מחזיר float
print(10 // 3)  # 3: חילוק שלם, משמיט את השארית
print(10 % 3)   # 1: מודולו, השארית
print(10 ** 3)  # 1000: חזקה

שני פריטים ברשימה הזו קל לשכוח:

• / מחזיר float גם כששני הצדדים מספרים שלמים. 10 / 2 נותן 5.0. לחילוק שלם, השתמשו ב-//.
• % הוא מודולו. n % 2 == 0 היא הדרך הנקייה ביותר לבדוק אם n זוגי.

Python פועלת לפי סדר הפעולות המתמטי הסטנדרטי: ** נקשר חזק יותר מ-* ו-/, שנקשרים חזק יותר מ-+ ו--. סוגריים גוברים על הכול:

print(2 + 3 * 4)      # 14, לא 20
print((2 + 3) * 4)    # 20

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

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

שש השוואות, שכל אחת מהן מחזירה ערך בוליאני:

print(5 == 5)    # True: שווים?
print(5 != 6)    # True: שונים?
print(5 < 6)     # True
print(5 <= 5)    # True
print(6 > 5)     # True
print(6 >= 6)    # True

Python מאפשרת לשרשר השוואות, וזה לא שגרתי ושימושי:

age = 25

if 18 <= age < 65:
    print("Working age")

זה נקרא "age הוא לפחות 18 ופחות מ-65". מאחורי הקלעים זה שקול ל-18 <= age and age < 65, אבל זה נקרא יותר כמו מתמטיקה.

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

נכתבים כמילים באנגלית, לא כסימנים:

logged_in = True
is_admin = False

print(logged_in and is_admin)   # False: שניהם חייבים להיות true
print(logged_in or is_admin)    # True: לפחות אחד חייב להיות true
print(not logged_in)            # False: הופך את הערך הבוליאני

שני פרטים שכדאי להכיר:

קיצור הערכה (short-circuit). and עוצר בערך ה-falsy הראשון, ו-or עוצר בערך ה-truthy הראשון. הצד השני אפילו לא מוערך אם הצד הראשון כבר הכריע את התשובה. זה מאפשר להתגונן מפני שגיאות בבטחה:

name = None

# name.upper() הייתה קורסת אם name הוא None,
# אבל קיצור ההערכה מציל אותנו.
if name is not None and name.upper() == "ADMIN":
    print("Admin access")
else:
    print("Not admin")

and/or מחזירים את הערך, לא תמיד True/False. הם מחזירים את האופרנד שהכריע את התוצאה:

print(0 or "default")    # "default"
print("" or "default")   # "default"
print("value" or "fallback")  # "value"

print(1 and "end")       # "end"
print(0 and "never")     # 0

תראו בקוד אמיתי name = user_input or "anonymous": זה דפוס של ערך ברירת מחדל שמבוסס על ההתנהגות הזו.

לכללים המלאים של שלושת האופרטורים האלה, כולל אילו ערכים נחשבים falsy, מה הקדימות של not, and ו-or זה מול זה, ולמה and אינו אותו דבר כמו &, ראו את and, or, not ב-Python.

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

= מבצע השמה. הצורות המורכבות משלבות פעולה עם השמה:

n = 10

n += 5    # כמו n = n + 5
n -= 2    # n = n - 2
n *= 3    # n = n * 3
n //= 2   # n = n // 2
n %= 4    # n = n % 4
n **= 2   # n = n ** 2

print(n)

הצורות המורכבות עובדות גם עם מחרוזות (s += "more") ועם רשימות (lst += [4, 5]). הן לא מהירות יותר מהכתיבה המלאה, רק קצרות יותר.

שייכות: in ו-not in

בודקים אם ערך מופיע בתוך מכולה:

colors = ["red", "green", "blue"]

print("red" in colors)         # True
print("yellow" not in colors)  # True

text = "hello world"
print("world" in text)         # True
print("z" not in text)         # True

contacts = {"alice": 1, "bob": 2}
print("alice" in contacts)     # True (בודק את המפתחות)

in עובד על כל iterable: רשימות, tuples, sets, מחרוזות, dicts ועוד. בחיפושים גדולים, in על רשימה הוא O(n), ו-in על set או dict הוא O(1). זה משנה ברגע שבודקים שייכות פעמים רבות.

זהות: is ו-is not

is בודק אם שני משתנים מצביעים על אותו אובייקט בזיכרון, ולא רק על ערכים שווים:

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

print(a == b)   # True: אותו תוכן
print(a is b)   # False: אובייקטים שונים
print(a is c)   # True: שניהם שמות של אותה רשימה

כמעט תמיד רוצים ==. המקום היחיד שבו is באמת מצטיין הוא בדיקה מול None, True ו-False:

value = None

if value is None:
    print("no value")

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

אופרטורי ביטים (דלגו על זה בקריאה ראשונה)

ל-Python יש גם אופרטורי ביטים, &, |, ^, ~, <<, >>, לשינוי ביטים בודדים של מספר שלם. הם שימושיים בקריפטוגרפיה, בתקשורת רשת ברמה נמוכה ובאלגוריתמים מסוימים. בקריאה ראשונה אפשר להתעלם מהם בבטחה.

אופרטור ה-Walrus (:=)

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

numbers = [1, 2, 3, 4, 5]

if (count := len(numbers)) > 3:
    print(f"Got {count} items - more than expected")

בלי ה-walrus הייתם קוראים ל-len(numbers) פעמיים או מוסיפים שורה. הוא לא הכרחי: השתמשו בו כשהוא מצמצם חזרות.

דף עזר לקדימות אופרטורים

מהקשירה החזקה ביותר לחלשה ביותר, עבור האופרטורים שתשתמשו בהם בפועל:

1. **: חזקה
2. *, /, //, %: כפל וחילוק
3. +, -: חיבור וחיסור
4. <, <=, >, >=, ==, !=: השוואות
5. not
6. and
7. or

כשיש ספק, הוסיפו סוגריים. בהירות עדיפה על תחכום.