2.3. פעולות מתמטיות

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

2.3.1. חשבון

האופרטורים החשבוניים הסטנדרטיים על ערכי int ו-float:

  • + – חיבור

  • - – חיסור (או שלילה, כקידומת: -x)

  • * – כפל

  • / – חילוק. תמיד מחזיר float, גם כאשר שני האופרנדים הם מספרים שלמים.

  • // – חילוק שלם (floor division). מחזיר את המנה השלמה המעוגלת כלפי מינוס אינסוף.

  • % – מודולו (שארית).

  • ** – חזקה (2 ** 10 הוא 1024).

>>> 7 / 2
3.5
>>> 7 // 2
3
>>> -7 // 2
-4
>>> 7 % 2
1
>>> 2 ** 16
65536

חשבון מעורב-טיפוסים מקדם מספרים שלמים ל-float באופן אוטומטי:

>>> 3 + 0.5
3.5

השמה מורחבת משלבת את האופרטור עם = לעדכון קומפקטי במקום:

counter = 0
counter += 1                # equivalent to counter = counter + 1
counter *= 2                # works for *= /= //= %= **= too

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

2.3.2. השוואה

אופרטורי השוואה מחזירים bool (True או False):

  • == ו-!= – שווה / לא שווה.

  • <, <=, >, >= – סדר.

>>> 3 == 3
True
>>> 3 == 3.0
True
>>> 3 < 5 <= 5
True

הדוגמה האחרונה היא השוואה משורשרת והיא שקולה בדיוק ל-3 < 5 and 5 <= 5.

אזהרה

= משייך; == משווה. הביטוי if x = 5: הוא שגיאת תחביר בדיוק משום ש-Python מסרבת לבלבל בין השניים בשקט.

2.3.3. לוגיקה בוליאנית

שלושה אופרטורים משלבים ערכים בוליאניים:

  • and – True רק כאשר שני הצדדים אמת.

  • or – True כאשר אחד הצדדים אמת.

  • not – הופך ערך בוליאני בודד.

and ו-or מקצרים מעגל: הם מפסיקים את ההערכה ברגע שהתוצאה ידועה. False and slow_check() לעולם לא קורא ל-slow_check.

and ו-or גם מחזירים את אחד מהאופרנדים שלהם במקום True או False ליטרלי, מה שמאפשר לך לכתוב ערכי ברירת מחדל בצורה קומפקטית:

name = user_name or "anonymous"   # "" / 0 / None are falsy

2.3.4. אופרטורים סיביתיים

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

  • & – AND סיביתי

  • | – OR סיביתי

  • ^ – XOR סיביתי

  • ~ – NOT סיביתי (משלים לאחד)

  • << – הזזה שמאלה

  • >> – הזזה ימינה

צורות הליטרל ההקסדצימליות והבינאריות נוחות בעת קריאה וכתיבה של אלה:

>>> 0b1100 & 0b1010
8                              # 0b1000
>>> 0b1100 | 0b1010
14                             # 0b1110
>>> 0xFF ^ 0x0F
240                            # 0xF0
>>> 1 << 8
256
>>> (0xABCD >> 8) & 0xFF
171                            # extract the high byte

קיימות צורות מורחבות לכל אחד: |=, &=, ^=, <<=, >>=.

הערה

and / or פועלים על ערכים בוליאניים (או על אמיתיוּת); & / | פועלים על סיביות. אל תבלבל ביניהם. 0b1100 and 0b1010 מעריך ל-0b1010 משום ששני האופרנדים אמיתיים – לא מה שאתה בדרך כלל רוצה בעת מניפולציה על סיביות.

2.3.5. פונקציות מובנות שימושיות למספרים

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

  • round() – המספר השלם הקרוב ביותר, או ndigits מקומות עשרוניים קרובים ביותר כאשר ניתן ארגומנט שני. מחזיר int עבור round(x), ו-float עבור round(x, n). תיקו (0.5, 1.5, …) מעוגל למספר הזוגי הקרוב ביותר, ולא תמיד כלפי מעלה.

  • divmod() – מחזיר (quotient, remainder) בקריאה אחת. שימושי לפיצול כמות אחת ליחידות (שניות לדקות ושניות, בתים לעמודים והיסטים).

  • pow() – זהה ל-** בצורה דו-ארגומנטית. הצורה התלת-ארגומנטית pow(base, exp, mod) מחשבת (base ** exp) % mod מבלי לממש אי פעם את הערך הביניים הענק, וזו הדרך המעשית היחידה לבצע חזקה מודולרית עבור מעריכים גדולים.

>>> round(3.7)
4
>>> round(3.14159, 2)
3.14
>>> round(0.5)               # ties go to even, not always up
0
>>> round(1.5)
2

>>> divmod(125, 60)          # 125 seconds = 2 min, 5 sec
(2, 5)
>>> minutes, seconds = divmod(125, 60)

>>> pow(3, 4)                # same as 3 ** 4
81
>>> pow(3, 100, 7)           # (3 ** 100) mod 7, efficient
4

המרות בסיס ממספר שלם למחרוזת (bin, oct, hex) מכוסות ב-מתודות מחרוזת ועיצוב.

2.3.6. מודול math

פונקציות מתמטיות נפוצות חיות במודול math. ייבא אותו פעם אחת וקרא לפונקציות שלו דרך שם עם נקודה:

import math

print(math.sqrt(2))              # 1.4142135
print(math.sin(math.pi / 2))     # 1.0
print(math.floor(3.7))           # 3
print(math.log(100, 10))         # 2.0

מודול math של MicroPython מכסה את החשודים הרגילים (sqrt, exp, log, sin, cos, tan, atan2, floor, ceil, pi, e, …). למספרים אקראיים, ראה את מודול random; לעבודת סיביות בנקודה קבועה, האופרטורים שלמעלה בדרך כלל מספיקים.

2.3.7. מספרים מרוכבים

לעבודה מספרית הזקוקה לרכיבים מדומים, ל-Python יש טיפוס complex עם ליטרלים בסיומת j (1 + 2j). מודול cmath משקף את math עבור קלטים מרוכבים. שניהם נוכחים ברוב גרסאות הבנייה של MicroPython אך נדרשים לעיתים רחוקות לעבודת מצלמה; אנו מזכירים אותם בעיקר כדי שלא יהוו הפתעה אם תעביר קוד המשתמש בהם.