האופרטורים and, or, not ב-Python: אופרטורים לוגיים, קיצור הערכה ו-Truthiness

שלוש מילים במקום סימנים

האופרטורים הלוגיים של Python הם המילים באנגלית and, or ו-not. בשפות אחרות כותבים אותם &&, || ו-!. ב-Python && ו-|| הם SyntaxError, ו-! מופיע רק כחלק מ-!= ("לא שווה").

has_ticket = True
is_adult = False

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

עם True ו-False הכללים הם אלה שמצפים להם:

and צריך ששני הצדדים יהיו אמת. or צריך לפחות אחד. not מקבל ערך יחיד והופך אותו.

בקוד אמיתי הצדדים הם בדרך כלל השוואות, והתוצאה מוזנת ל-if או ל-while:

age = 34
country = "CA"

if age >= 18 and country in ("US", "CA"):
    print("eligible")

if age < 13 or age > 65:
    print("discounted ticket")
else:
    print("standard ticket")

פלט:

eligible
standard ticket

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

ערכים truthy ו-falsy

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

• False ו-None
• אפס מכל טיפוס מספרי: 0, 0.0
• מכולות ומחרוזות ריקות: "", [], (), {}, set(), range(0)

כל השאר truthy, כולל "0", "False", [0] ו--1. אפשר לראות איך Python מסווגת ערך בעזרת bool():

for value in [0, 1, -1, "", "0", [], [0], None, 0.0]:
    print(repr(value), bool(value))

פלט:

0 False
1 True
-1 True
'' False
'0' True
[] False
[0] True
None False
0.0 False

המחרוזת "0" היא truthy כי היא מחרוזת לא ריקה. זה תופס אנשים שקוראים מספרים מהקלט ובודקים אותם לפני ההמרה. העמוד על מספרים ובוליאנים מסביר את הקשר בין bool ל-int.

and ו-or מחזירים אופרנד

כאן Python שונה מרוב השפות. and ו-or לא מייצרים True או False חדשים. הם מחזירים אחד משני הערכים שנתתם להם:

• x or y מחזיר את x אם x הוא truthy, ואחרת מחזיר את y.
• x and y מחזיר את x אם x הוא falsy, ואחרת מחזיר את y.

print(0 or 5)            # 5
print(3 or 5)            # 3
print("" or "guest")     # guest
print([] or None)        # None

print(0 and 5)           # 0
print(3 and 5)           # 5
print("a" and "b")       # b
print(None and 1 / 0)    # None, ובלי ZeroDivisionError

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

not הוא היוצא מן הכלל: הוא תמיד מחזיר True או False.

print(not 0)        # True
print(not "hi")     # False
print(not [])       # True

אם אתם צריכים ערך בוליאני אמיתי מביטוי and/or, למשל כדי לשמור אותו או להחזיר אותו מפונקציה שמבטיחה bool, עטפו אותו ב-bool():

name = "Ada"
email = ""

print(name and email)         # מדפיס שורה ריקה: הערך הוא ""
print(bool(name and email))   # False

קיצור הערכה (Short-Circuit)

Python מעריכה את and ואת or משמאל לימין ועוצרת ברגע שהתשובה ידועה:

• and עוצר בערך ה-falsy הראשון, כי שום דבר אחריו לא יכול להפוך את כל הביטוי לאמת.
• or עוצר בערך ה-truthy הראשון, כי שום דבר אחריו לא יכול להפוך את כל הביטוי לשקר.

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

def check(label, result):
    print(f"  checking {label}")
    return result

print("and:")
print(check("A", False) and check("B", True))

print("or:")
print(check("A", True) or check("B", False))

פלט:

and:
  checking A
False
or:
  checking A
True

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

user = None
items = []

if user is not None and user.startswith("admin"):
    print("admin")
else:
    print("not an admin")

if items and items[0] > 10:
    print("first item is large")
else:
    print("no large first item")

שימו את הבדיקה הזולה או המגינה ראשונה. היפוך הסדר, user.startswith("admin") and user is not None, זורק AttributeError כש-user הוא None.

דפוסים שמבוססים על or ו-and

מכיוון ש-or מחזיר את האופרנד ה-truthy הראשון שלו, הוא נותן ערך ברירת מחדל בשורה אחת:

def greet(name):
    name = name or "guest"
    print(f"Hello, {name}!")

greet("Ada")
greet("")
greet(None)

פלט:

Hello, Ada!
Hello, guest!
Hello, guest!

הבעיה היא ש-or מחליף כל ערך falsy, לא רק את None. אם 0, "" או [] הם קלט לגיטימי, or ייפטר ממנו:

volume = 0
print(volume or 50)                           # 50: ה-0 הוחלף

print(volume if volume is not None else 50)   # 0: רק None מוחלף

השתמשו ב-x if x is not None else default כשאפס או ערך ריק הם ערך תקין. העמוד על if/else מסביר את ביטוי התנאי הזה.

ל-and יש דפוס מקביל: "השתמש בערך הזה רק אם הראשון מוגדר". הוא פחות נפוץ ולעיתים קרובות ברור יותר כ-if, אז השתמשו בו במשורה:

user = {"name": "Ada"}
print(user and user["name"])   # Ada

user = None
print(user and user["name"])   # None

קדימות: not, אחריו and, ואחריו or

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

a, b, c = True, False, False

print(a or b and c)      # True: נקרא כ-a or (b and c)
print((a or b) and c)    # False
print(not a or b)        # False: נקרא כ-(not a) or b
print(not (a or b))      # False
print(not 1 == 2)        # True: נקרא כ-not (1 == 2)

a or b and c ו-(a or b) and c נותנים תשובות שונות מאותם ערכים, ולכן תנאי מעורב צריך סוגריים גם כשסדר ברירת המחדל במקרה נכון. הם לא עולים כלום ומורידים את השאלה מהקורא הבא.

and/or לעומת &/|

& ו-| נראים דומים ל-and ול-or ולפעמים נותנים אותה תשובה, אבל הם אופרטורים שונים.

• and / or בודקים truthiness, מקצרים את ההערכה ומחזירים אחד מהאופרנדים.
• & / | הם אופרטורים של ביטים. על מספרים שלמים הם משלבים את הביטים של שני המספרים. על sets פירושם חיתוך ואיחוד. על True ו-False הם מחזירים ערך בוליאני. הם אף פעם לא מקצרים: שני הצדדים תמיד מוערכים.

print(6 and 3)   # 3: 6 הוא truthy, ולכן and מחזיר את האופרנד השני
print(6 & 3)     # 2: 110 & 011 = 010 בבינארי

print(6 or 3)    # 6
print(6 | 3)     # 7: 110 | 011 = 111

print({1, 2, 3} & {2, 3, 4})   # {2, 3}
print(True & False)             # False

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

x, y = 5, 5

print(x > 1 and y > 1)     # True
print(x > 1 & y > 1)       # False: נקרא כ-x > (1 & y) > 1
print((x > 1) & (y > 1))   # True, אבל הסוגריים חובה

1 & y הוא 1 & 5, כלומר 1, ולכן השורה האמצעית הופכת לשרשרת 5 > 1 > 1, ו-1 > 1 שקרי. בקוד Python רגיל, השתמשו ב-and, or ו-not לתנאים.

המקום היחיד שבו &, | ו-~ נכונים לתנאים הוא NumPy ו-pandas. מערך מחזיק ערכים רבים, ולכן אין לו ערך אמת יחיד, ו-and זורק ValueError: The truth value of an array ... is ambiguous. הספריות מעמיסות את & ואת | כך שיעבדו איבר אחר איבר, ולכן סינונים ב-pandas נראים כמו df[(df.age > 18) & (df.country == "CA")], עם סוגריים סביב כל השוואה בגלל סיבת הקדימות שלמעלה.

any() ו-all(): and ו-or על רשימה

כדי לשלב רצף שלם של תנאים, השתמשו בפונקציות המובנות all() (and על כל הפריטים) ו-any() (or על כל הפריטים). שתיהן מקצרות את ההערכה באותו אופן:

scores = [72, 88, 95, 61]

print(all(s >= 60 for s in scores))   # True: כל הציונים עברו
print(any(s >= 90 for s in scores))   # True: לפחות ציון מצוין אחד
print(any(s < 50 for s in scores))    # False

print(all([]))   # True: שום דבר לא נכשל
print(any([]))   # False: שום דבר לא עבר

בניגוד ל-and ו-or, any() ו-all() תמיד מחזירות ערך בוליאני.

טעויות נפוצות

השוואת משתנה אחד לכמה ערכים עם or. התנאי הזה תמיד אמת:

color = "green"

if color == "red" or "blue":
    print("matched (wrong!)")

if color == "red" or color == "blue":
    print("matched")
else:
    print("no match")

if color in ("red", "blue"):
    print("matched")
else:
    print("no match")

Python קוראת את התנאי הראשון כ-(color == "red") or "blue". ההשוואה היא False, ולכן or מחזיר את "blue", מחרוזת לא ריקה, שהיא truthy. חזרו על ההשוואה בשני הצדדים, או עדיף, בדקו שייכות עם in.

כתיבת && או ||. שניהם SyntaxError. השתמשו ב-and וב-or.

ציפייה לערך בוליאני מ-and/or. x = a or b שומר את a או את b עצמם. לרוב זה מה שרוצים, אבל אם פונקציה צריכה להחזיר True או False, המירו עם bool().

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