Bitwise Operators in Python Explained with Examples

Bitwise operators in Python are a set of special symbols that enable you to deal with the individual bits of the binary representation of integers directly. That is, instead of whole numbers, these operators work on the binary form of the numbers and execute the operations bit by bit. Therefore, these operators become very powerful in cases where fast, low-level data processing or efficient storage of data is required.

The following table summarizes the main bitwise operators available in Python, including their symbols and a brief description of what each one does:

Understanding bitwise operators is easier with hands-on examples. Below are practical code snippets that demonstrate how to use each bitwise operator in Python, along with explanations and their outputs.

1. Bitwise AND Operator (&)

The AND bitwise operator in Python is used to compare two numbers at the binary level. In bitwise in Python, it checks each bit (the 1s and 0s that make up a number) of both numbers. The outcome is 1 if both bits in the same place are 1. The outcome is 0 if either bit is 0.

How the Bitwise AND Work?

Let's take an example:

• a = 10 (which is 1010 in binary)
• b = 7 (which is 0111 in binary)

When we perform a & b, the bits are compared like this, then only the third bit from the right matches (1 & 1), so the result is 0010, which equals 2 in decimal form.

  1010
&0111
------
  0010

Code Example

a = 10
b = 7
result = a & b
print(result)

Output

2

2. Bitwise OR Operator (|)

The Bitwise OR operator (|) compares two numbers by looking at their binary form, checking each bit. If at least one bit is 1, it returns 1; if not, it returns 0.  In short, Bitwise Operators in Python, like OR, combine the 1s from both numbers, making it useful when you want to set specific bits without affecting others.

How the Bitwise OR Works?

For example:

• a = 10 (binary: 1010)
• b = 7 (binary: 0111)

When we apply a | b, the bits are compared like this:

 1010
|0111
------
  1111

Code Example

a = 10
b = 7
result = a | b
print(result)

Output

15

3. Bitwise XOR Operator (^)

The Bitwise XOR operation in Python compares two numbers bit by bit and returns 1 if the bits are different, meaning exactly one of the two bits is 1. It gives 0 if both bits are the same, either 0 or 1. In simple terms, XOR highlights the bits that are different between two numbers and is commonly used in encryption, toggling bits, or finding differences when working with bitwise in Python.

How the Bitwise XOR Works?

Consider:

• a = 10 (binary: 1010)
• b = 7 (binary: 0111)

When we perform a ^ b, the comparison looks like this, where the bits are different, the result is 1. 1101 in binary equals 13 in decimal.

 1010
^0111
------
  1101

Code Example

a = 10
b = 7
result = a ^ b
print(result)

Output

13

4. Bitwise NOT Operator (~)

The Bitwise NOT operator in Python is a unary operator, meaning it works on just one number. It flips every bit in the binary form: all 0s become 1s, and all 1s become 0s. In Python, numbers are stored in a format called two’s complement, so when you apply ~ to a number x, the result is actually -(x + 1). This Bitwise Operator in Python is useful when you need the opposite bits of a number.

How does the Bitwise NOT work?

Suppose we have:

• a = 10 (binary representation: 0000 1010)

When we apply ~a, each bit is flipped. Then this result (1111 0101) represents -11 in decimal using two’s complement notation.

~0000 1010
=1111 0101

Code Example

a = 10
result = ~a
print(result)

Output

-11

5. Bitwise Left Shift Operator (<<)

The Left Shift operator in Python moves all the bits of a number to the left by a given number of positions, filling empty spaces on the right with zeros. In bitwise in Python, each shift to the left multiplies the number by 2, making it useful for quickly multiplying by powers of two.

How the Bitwise << Work?

Let’s see an example:

• a = 10 (binary: 1010)

If we shift a to the left by 2 positions (a << 2), then the new binary number 101000 equals 40 in decimal. So shifting left by 2 is the same as multiplying 10 × 2² = 40 as:

 1010 << 2
= 101000

Code Example

a = 10
result = a << 2
print(result)

Output

40

6. Bitwise Right Shift Operator (>>)

The Bitwise Right Shift operator in Python shifts the bits of a number to the right. In Bitwise Operators in Python, this moves each bit one position right, filling the leftmost bits based on the number’s sign. Each right shift effectively divides the number by 2, ignoring the remainder.

How the Bitwise >> Work?

Let’s consider an example:

• a = 10 (which is 1010 in binary)

When we shift a right by 1 position, then this gives the binary value 0101, which equals 5 in decimal as:

 1010 >> 1
= 0101

Code Example

a = 10
result = a >> 1
print(result)

Output

5

Summary:

These examples show how bitwise operators work with integers and how some operators are overloaded for set operations in Python. Practicing these snippets will help you master bitwise manipulations for a variety of tasks.

Bitwise operators (like &, |, ^, ~, <<, and>>) in Python can have their behavior altered for your own classes. This is called operator overloading. By defining special methods in your class, you allow objects of that class to perform bitwise operations just like integers, but with custom behavior that fits your needs.

Why Overload Bitwise Operators?

Operator overloading lets you make your custom objects support intuitive bitwise operations. Using operators like &, or | makes your code clearer and more expressive, which is helpful for creating classes that represent bitfields, flags, or other data structures.

Special Methods for Bitwise Operator Overloading

Use these unique methods in your class to overload bitwise operators:

• __and__(self, other) for &
• __or__(self, other) for |
• __xor__(self, other) for ^
• __invert__(self) for ~
• __lshift__(self, other) for <<
• __rshift__(self, other) for >>

Example: Overloading Multiple Bitwise Operators

Below is an example class that overloads several bitwise operators:

class BitwiseNumber:
    def init(self, value):
        self.value = value

    def __and__(self, other):
        print("AND operator overloaded")
        return BitwiseNumber(self.value & other.value)

    def __or__(self, other):
        print("OR operator overloaded")
        return BitwiseNumber(self.value | other.value)

    def __xor__(self, other):
        print("XOR operator overloaded")
        return BitwiseNumber(self.value ^ other.value)

    def __invert__(self):
        print("INVERT operator overloaded")
        return BitwiseNumber(~self.value)

    def __lshift__(self, other):
        print("LEFT SHIFT operator overloaded")
        return BitwiseNumber(self.value << other.value)

    def __rshift__(self, other):
        print("RIGHT SHIFT operator overloaded")
        return BitwiseNumber(self.value >> other.value)

    def __str__(self):
        return str(self.value)

Usage Example

a = BitwiseNumber(10)

b = BitwiseNumber(7)

print(a & b)    # AND operator overloaded, Output: 2
print(a | b)    # OR operator overloaded, Output: 15
print(a ^ b)    # XOR operator overloaded, Output: 13
print(~a)       # INVERT operator overloaded, Output: -11
print(a << b)   # LEFT SHIFT operator overloaded, Output: 1280
print(a >> b)   # RIGHT SHIFT operator overloaded, Output: 0

Code Explanation

In this example, the BitwiseNumber class overloads several bitwise operators. For instance, when you write a & b, Python calls the __and__ method, which performs the bitwise AND operation between the values and returns a new BitwiseNumber object. The same pattern applies for the other operators.

• Time complexity: O(1) for each bitwise operation.
• Space complexity: O(1) for storing the result.

When to Use Operator Overloading

Consider overloading bitwise operators when you want your custom classes to behave like numbers or sets with respect to bitwise operations. For example, Python’s built-in set and frozenset types overload |, &, and ^ to mean union, intersection, and symmetric difference. Operator overloading makes your custom classes more intuitive and easier to use.

Bitwise operators are more than just theoretical tools; they are essential to many practical programming jobs where direct binary manipulation, memory efficiency, and performance are critical. Bitwise operations are very helpful in the following typical situations:

1. Flag Management and Bitfields

Bitwise operators are like tools that are most commonly used to handle flags, binary indicators that express various states or options within a single integer. With the help of bitwise AND, OR, and NOT, one can very well set, clear, or check individual bits without the need to change other bits. The technique in question finds its uses in the configurations of the settings, permissions, and feature toggles.

2. Data Compression and Encryption

Bitwise operations serve as an opening to data manipulation on the bit level in algorithms that demand compact data representation. The reality is that the same is very necessary in cryptography, where data is to be masked, shifted, or combined securely and in data compression, where each bit is tightly packed so as to save space.

3. Image Processing and Computer Vision

In image processing, bitwise operations are employed to directly modify pixel values. For instance, bitwise OR or XOR can be used to merge pictures or draw attention to discrepancies, while bitwise AND can be used to mask certain areas of an image. These methods form the basis of computer vision algorithms.

4. Low-Level Programming and Hardware Communication

In systems programming, bitwise operations are the primary methods by which software communicates with hardware devices. They are extensively used for setting or reading specific bits in device registers, as well as for creating efficient protocols. Shifting and masking operations are typically involved in the processes of packing and unpacking data in the most efficient way.

5. Optimization in Algorithms

Some algorithms, particularly those which require rapid arithmetic or logical operations, incorporate bitwise operators as a means of performance optimization. Among such cases are the following: determining the parity of a number (using x & 1), value swapping without a temporary variable, or fast multiplication/division by powers of two through the use of left and right shift operations.

6. Data Science and Efficient Data Manipulation

Bitwise operators find their place in data science as well, serving as a tool for feature engineering in situations such as the extraction or combination of categorical features represented in the form of binary flags. Moreover, they are employed in performing efficient data cleaning and manipulation steps, especially when handling large datasets or binary, encoded information.

Summary:

Bitwise operators are strong instruments that make it possible to manipulate data at the binary level with accuracy and efficiency. Gaining proficiency with these operators will enable you to develop code that is quicker, more memory-efficient, and more elegant—whether you work in data science, systems programming, encryption, or image processing.

Bitwise operators in Python are used in situations where performance and memory efficiency are essential. These operators perform operations directly on the individual bits of data, which can be faster and more memory-efficient than other methods. Here are some points to keep in mind when using bitwise operators:

• Integer Only Operations: Bitwise operators should always be used with integers. If you attempt to use them with other types, such as strings or floats, Python will raise a TypeError.
• Handling Negative Numbers: Python uses the two's complement to express negative values. The bitwise NOT (~) operator in particular is impacted by this way of storing negative values. The NOT operator may yield results that differ from what you might anticipate based on basic arithmetic when applied to a negative integer.
• Clarity in Complex Expressions: It's a good idea to use parenthesis to make difficult bitwise operations easier to understand. Parentheses can guarantee that activities are carried out in the correct order and help prevent misunderstanding.

Bitwise operators in Python are effective tools for binary data manipulation. You may develop code that is quicker, more memory-efficient, and more appropriate for jobs requiring low-level data processing by knowing how each operator functions and when to apply it. Gaining proficiency in bitwise operations allows you to create sophisticated and efficient solutions for a variety of programming problems, whether you're handling flags, making masks, or doing direct binary manipulation.

Advice for Learners

1. Bitwise operators always work at the binary level, even though the input and output appear as decimal numbers.
   Python uses two’s complement representation, which directly affects the behavior of the bitwise NOT (~) operator.
2. Left and right shift operations are efficient alternatives for multiplying or dividing by powers of two.
3. Bitwise operators only work with integers; applying them to other data types raises errors.
4. For performance-sensitive activities like flags, masks, and low-level data manipulation, bitwise logic works well.

1. What are bitwise operators in Python used for?

For tasks like flag management and low-level data handling, bitwise operators in Python modify the individual bits of integers.

2. Can bitwise operators be used with non-integer types in Python?

No, bitwise operators only work with integers. Using them with other types will result in an error.

3. How does the bitwise NOT operator (~) work in Python?

The bitwise NOT operator (~) flips all bits of an integer. For example, ~10 results in -11.

4. What is the difference between bitwise AND (&) and bitwise OR (|) in Python?

Bitwise AND (&) sets a bit to 1 only if both bits are 1. Bitwise OR (|) sets a bit to 1 if at least one bit is 1.

5. How can I convert a decimal number to binary in Python for bitwise operations?

You can use the bin() function to convert a decimal number into binary, which helps in performing bitwise operations.

6. What are the common applications of bitwise operators in Python programming?

Bitwise operators are used in flag management, cryptography, graphics, and performance optimization by working directly with bits.