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

אופרטורי Bitwise ב-Python

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

ב-Python ישנם 6 אופרטורי Bitwise. הטבלה למטה מספקת פרטים קצרים עליהם.

1. אופרטור Bitwise AND

אופרטור Bitwise and ב-Python מחזיר 1 אם שני הביטים הם 1, אחרת 0.

>>> 10&7
2
>>> 

2. אופרטור Bitwise OR

אופרטור Bitwise or ב-Python מחזיר 1 אם אחד מהביטים הוא 1. אם שני הביטים הם 0, אז הוא מחזיר 0.

>>> 10|7
15
>>> 

3. אופרטור XOR בינארי

אופרטור XOR בפייתון מחזיר 1 אם אחד מהביטים הוא 0 והביט השני הוא 1. אם שני הביטים הם 0 או 1, התוצאה היא 0.

>>> 10^7
13
>>> 

4. אופרטור תיקוני התמלאות לבינארי אחד

ההשלמה הבינארית (Ones’ complement) של מספר 'A' בפייתון היא שווה ל-(A+1).

>>> ~10
-11
>>> ~-10
9
>>> 

5. אופרטור הזזת בינארי לשמאל

אופרטור הזזת בינארי לשמאל בפייתון מזיז את ביטי המקור לכיוון השמאלי למספר הנתון שבאמצעות הפעולה בין האופרנדים. במילים פשוטות, המספר הבינארי מתווסף ב-0 בסופו.

>>> 10 << 2
40
>>> 

6. אופרטור הזזת בינארי לימין

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

>>> 10 >> 2
2
>>>  

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

פייתון תומך בעמסת אופרטורים. ישנם שיטות שונות שאנו יכולים ליישם כדי לתמוך באופרטורים לביטיים עבור אובייקטים מותאמים אישית שלנו.

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

class Data:
    id = 0

    def __init__(self, i):
        self.id = i

    def __and__(self, other):
        print('Bitwise AND operator overloaded')
        if isinstance(other, Data):
            return Data(self.id & other.id)
        else:
            raise ValueError('Argument must be object of Data')

    def __or__(self, other):
        print('Bitwise OR operator overloaded')
        if isinstance(other, Data):
            return Data(self.id | other.id)
        else:
            raise ValueError('Argument must be object of Data')

    def __xor__(self, other):
        print('Bitwise XOR operator overloaded')
        if isinstance(other, Data):
            return Data(self.id ^ other.id)
        else:
            raise ValueError('Argument must be object of Data')

    def __lshift__(self, other):
        print('Bitwise Left Shift operator overloaded')
        if isinstance(other, int):
            return Data(self.id << other)
        else:
            raise ValueError('Argument must be integer')

    def __rshift__(self, other):
        print('Bitwise Right Shift operator overloaded')
        if isinstance(other, int):
            return Data(self.id >> other)
        else:
            raise ValueError('Argument must be integer')

    def __invert__(self):
        print('Bitwise Ones Complement operator overloaded')
        return Data(~self.id)

    def __str__(self):
        return f'Data[{self.id}]'


d1 = Data(10)
d2 = Data(7)

print(f'd1&d2 = {d1&d2}')
print(f'd1|d2 = {d1|d2}')
print(f'd1^d2 = {d1^d2}')
print(f'd1<<2 = {d1<<2}')
print(f'd1>>2 = {d1>>2}')
print(f'~d1 = {~d1}')

פלט:

Bitwise AND operator overloaded
d1&d2 = Data[2]
Bitwise OR operator overloaded
d1|d2 = Data[15]
Bitwise XOR operator overloaded
d1^d2 = Data[13]
Bitwise Left Shift operator overloaded
d1<<2 = Data[40]
Bitwise Right Shift operator overloaded
d1>>2 = Data[2]
Bitwise Ones Complement operator overloaded
~d1 = Data[-11]

אם אינך מוכר עם פורמט המחרוזת החדש, יש לקרוא על f-strings בפייתון.

סיכום

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