אופרטורים בפייתון

אופרטורים בפייתון

מאמר זה מסביר על אופרטורים בפייתון.

YouTube Video

אופרטורים בפייתון

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

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

אופרטורים אריתמטיים הם אופרטורים המשמשים לביצוע חישובים על מספרים.

אופרטור משמעות דוגמא
+ חיבור 3 + 25
- חיסור 3 - 21
* כפל 3 * 26
/ חילוק (תמיד תוצאה עשרונית) 3 / 21.5
// חילוק שלם 3 // 21
% שארית (מודולו) 3 % 21
** העלאה בחזקה 3 ** 29
 1a = 10
 2b = 3
 3
 4print(f"{a} + {b} = {a + b}")     # Addition
 5print(f"{a} - {b} = {a - b}")     # Subtraction
 6print(f"{a} * {b} = {a * b}")     # Multiplication
 7print(f"{a} / {b} = {a / b}")     # Division (float)
 8print(f"6 / 3 = {6 / 3}")         # Division (float)
 9print(f"{a} // {b} = {a // b}")   # Floor Division
10print(f"{a} % {b} = {a % b}")     # Modulo (remainder)
11print(f"{a} ** {b} = {a ** b}")   # Exponentiation
  • בנוסף לארבע פעולות החשבון הבסיסיות, פייתון מספקת אופרטורים לחלוקה (/), חלוקה שלמה (//), מודולו (%) וחזקה (**). חילוק מחזיר מספר עשרוני (floating-point) גם כאשר מחלקים מספרים שלמים.

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

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

אופרטור משמעות דוגמה
= הצבה x = 5
+= הוספה והצבה x += 2x = x + 2
-= חיסור והצבה x -= 2x = x - 2
*= כפל והצבה x *= 2x = x * 2
/= חילוק והצבה x /= 2x = x / 2
//= חילוק שלם x //= 2x = x // 2
%= הצבת שארית x %= 2x = x % 2
**= הצבה של חזקות x **= 2x = x ** 2
&= השמה בעזרת AND x &= 0b1010x = x & 0b1010
|= השמה בעזרת OR x | = 0b0011x = x | 0b0011
^= השמה בעזרת XOR x ^= 0b0101x = x ^ 0b0101
<<= השמה לאחר הזזה שמאלה x <<= 2x = x << 2
>>= השמה לאחר הזזה ימינה x >>= 1x = x >> 1
:= ביטוי השמה (אופרטור וואלרוס) if (n := len(data)) > 10:השמה ל-n בזמן חישוב התנאי
 1x = 5           # x = 5
 2
 3x += 3          # x = x + 3
 4x -= 2          # x = x - 2
 5x *= 4          # x = x * 4
 6x /= 3          # x = x / 3
 7x //= 2         # x = x // 2
 8x %= 5          # x = x % 5
 9x **= 3         # x = x ** 3
10
11x = 0b1100      # x = 0b1100 (12)
12
13x &= 0b1010     # x = x & 0b1010
14x |= 0b0011     # x = x | 0b0011
15x ^= 0b0101     # x = x ^ 0b0101
16x <<= 2         # x = x << 2
17x >>= 1         # x = x >> 1
18
19print(bin(x))   # Display in binary
20print(x)        # Display in decimal
21
22# Walrus operator
23if (n := len("hello")) > 3:
24    print(f"Length is {n}")
  • אופרטורי השמה מאפשרים לשלב השמה רגילה עם אופרטורים שונים כדי להקצות את התוצאה.
  • אופרטור הוואלרוס (:=) הוא ביטוי השמה הזמין החל מגרסה 3.8 של פייתון.
  • בעוד שהשמה רגילה יכולה לשמש רק כמשפט, אופרטור הוואלרוס מאפשר השמה בתוך ביטוי.

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

אופרטורים להשוואה משווים ערכים ומחזירים True או False.

אופרטור משמעות דוגמא
== שווה 3 == 3True
!= לא שווה 3 != 4True
> גדול מ- 5 > 2
< קטן מ- 5 < 2
>= גדול או שווה ל- 5 >= 5
<= קטן או שווה ל- 3 <= 4
 1a = 10
 2b = 20
 3
 4# Equal to (==)
 5print(f"{a} == {b} -> {a == b}")      # False: a and b are not equal
 6print(f"3 == 3.0 -> {3 == 3.0}")      # True: int and float with the same value are equal
 7print(f"3 == '3' -> {3 == '3'}")      # False: different types (int vs str)
 8print(f"True == 1 -> {True == 1}")    # True: True is equivalent to 1
 9print(f"False == 0 -> {False == 0}")  # True: False is equivalent to 0
10print(f"None == 0 -> {None == 0}")    # False: None is not equal to 0
11
12# Not equal to (!=)
13print(f"{a} != {b} -> {a != b}")      # True: a and b are not equal
14
15# Greater than (>)
16print(f"{b} > {a} -> {b > a}")        # True: 20 > 10
17
18# Less than (<)
19print(f"{a} < {b} -> {a < b}")        # True: 10 < 20
20
21# Greater than or equal to (>=)
22print(f"{a} >= 10 -> {a >= 10}")      # True: a is greater than or equal to 10
23
24# Less than or equal to (<=)
25print(f"{a} <= 10 -> {a <= 10}")      # True: a is less than or equal to 10
  • אופרטורי השוואה משווים בין שני ערכים לסדר או לשוויון ומחזירים תוצאה של True או False.
  • ב-Python, יש להיזהר כאשר משווים בין סוגי נתונים שונים. ניתן להשוות בין סוגים מסוימים, אך התוצאות לא תמיד אינטואיטיביות.

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

אופרטורים לוגיים משמשים לשילוב ביטויים לוגיים.

אופרטור משמעות דוגמא
and מחזיר אמת אם שניהם אמת True and FalseFalse
or מחזיר אמת אם אחד מהם אמת True or FalseTrue
not הופך את הערך הבוליאני not TrueFalse
1x = 10
2print(x > 5 and x < 20)  # True
3print(x < 5 or x > 20)   # False
4print(not x == 10)       # False
  • and הוא אופרטור לוגי שמחזיר True רק אם שני התנאים מימין ומשמאל הם True.
  • or הוא אופרטור לוגי שמחזיר True אם אחד מהתנאים מימין או משמאל הוא True.
  • not הוא אופרטור לוגי שהופך את ערך האמת של תנאי. אם זה נכון, זה הופך לשקר, ואם זה שקר, זה הופך לנכון.

קדימות של אופרטורים לוגיים

לאופרטורים יש קדימות. זו הכלל שקובע איזה אופרטור מוערך ראשון בביטוי. אופרטורים לוגיים מוערכים לפי הסדר: not, ואז and, ואז or.

1result = True or False and False
2print(result)  # True
3
4result = (True or False) and False
5print(result)  # False

たとえば、

בדוגמה הראשונה, and מוערך ראשון, אז False and False הופך ל-False, וכתוצאה מכך, True or False נהיה True. ניתן גם לשנות את סדר ההערכה באמצעות סוגריים, כפי שמוצג בדוגמה השנייה.

אופרטורים ביטיים

אופרטורים חישוביים מבצעים פעולות ברמת הסיבית.

אופרטור משמעות דוגמא
& AND ברמת סיביות 5 & 31
| OR ברמת סיביות 5 | 37
^ XOR (או בלעדי) ברמת סיביות 5 ^ 36
~ NOT ברמת סיביות ~5-6
<< הזזה שמאלה (Left shift) 5 << 110
>> הזזה ימינה (Right shift) 5 >> 12
 1# Sample code for bitwise operators
 2
 3# Define two integers
 4a = 5  # Binary: 0101
 5b = 3  # Binary: 0011
 6
 7# Bitwise AND
 8result_and = a & b  # Binary: 0001 -> Decimal: 1
 9print(f"{a} & {b} = {result_and}")
10
11# Bitwise OR
12result_or = a | b  # Binary: 0111 -> Decimal: 7
13print(f"{a} | {b} = {result_or}")
14
15# Bitwise XOR
16result_xor = a ^ b  # Binary: 0110 -> Decimal: 6
17print(f"{a} ^ {b} = {result_xor}")
18
19# Bitwise NOT (inverting bits)
20result_not = ~a  # Binary: -(0101 + 1) -> Decimal: -6
21print(f"~{a} = {result_not}")
22
23# Left shift
24shift_left = a << 1  # Binary: 1010 -> Decimal: 10
25print(f"{a} << 1 = {shift_left}")
26
27# Right shift
28shift_right = a >> 1  # Binary: 0010 -> Decimal: 2
29print(f"{a} >> 1 = {shift_right}")
  • ניתן לבצע פעולות ביטווייז AND, OR, XOR, NOT וכן פעולות הזזה של ביטים. ניתן גם לשלב אותם עם אופרטורי השמה כמו &=.

אופרטורים של חברות

אופרטורים של חברות משמשים עם אוספים כגון רשימות ומילונים.

 1x = [1, 2, 3]
 2y = 2
 3z = 4
 4
 5print("y in x : ", y in x)  # Result is True
 6print("z in x : ", z in x)  # Result is False
 7
 8print("y not in x : ", y not in x)  # Result is False
 9print("z not in x : ", z not in x)  # Result is True
10
11text = "hello world"
12print("'world' in 'hello world' : ",      "world" in text)      # True
13print("'python' not in 'hello world' : ", "python" not in text) # True
  • in האופרטור משמש כדי לבדוק האם ערך מסוים קיים בתוך רצף כמו רשימה או מחרוזת, או אוסף כמו מילון.
  • not in האופרטור משמש כדי לבדוק האם ערך מסוים אינו קיים בתוך רצף או אוסף.

אופרטורים של זהות

אופרטורים של זהות בודקים את הזהות של אובייקטים.

 1x = [1, 2, 3]
 2y = x
 3z = x.copy()
 4
 5print("x is y : ", x is y)  # Result is True
 6print("x is z : ", x is z)  # Result is False
 7
 8print("x is not y : ", x is not y)  # Result is False
 9print("x is not z : ", x is not z)  # Result is True
10
11print("x == y : ", x == y)  # Result is True
12print("x == z : ", x == z)  # Result is True
  • האופרטור is בודק האם שני אובייקטים הם אותו אובייקט (כלומר, מתייחסים לאותו מקום בזיכרון).
  • האופרטור is not בודק האם שני אובייקטים הם אובייקטים שונים.
  • לדוגמה, x is y שונה מ-x == y בכך שהוא בודק זהות אובייקטים, ולא שוויון ערך.

בדיקת טיפוס

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

 1x = 10
 2print(isinstance(x, int))  # True
 3
 4y = "hello"
 5print(isinstance(y, str))  # True
 6
 7z = [1, 2, 3]
 8print(isinstance(z, list))  # True
 9
10print(type(10))        # <class 'int'>
11print(type("hello"))   # <class 'str'>
12
13print("isinstance(3, int) : ", isinstance(3, int))  # True
14print("type(3) is int : ", type(3) is int)          # True
15print("type(True) is bool : ", type(True) is bool)  # True
  • isinstance() היא פונקציה שבודקת האם אובייקט הוא מופע של מחלקה מסוימת או של תת-מחלקה שלה.
  • type() היא פונקציה שמחזירה את הסוג (מחלקה) המדויק של האובייקט. בדרך כלל משתמשים בה כאשר רוצים לבצע השוואה מחמירה של טיפוסים.
  • isinstance() מתחשב ביחסי ירושה, בעוד type() בודק התאמה מדויקת.

סיכום

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

תוכלו לעקוב אחר המאמר שלמעלה באמצעות Visual Studio Code בערוץ היוטיוב שלנו. נא לבדוק גם את ערוץ היוטיוב.

YouTube Video